#!/usr/bin/perl

# BEGIN DATAPACK CODE
{
    my $toc;
    my $data_linepos = 1;
    unshift @INC, sub {
        $toc ||= do {

            my $fh = \*DATA;

        my $header_line;
        my $header_found;
        while (1) {
            my $header_line = <$fh>;
            defined($header_line)
                or die "Unexpected end of data section while reading header line";
            chomp($header_line);
            if ($header_line eq 'Data::Section::Seekable v1') {
                $header_found++;
                last;
            }
        }
        die "Can't find header 'Data::Section::Seekable v1'"
            unless $header_found;

        my %toc;
        my $i = 0;
        while (1) {
            $i++;
            my $toc_line = <$fh>;
            defined($toc_line)
                or die "Unexpected end of data section while reading TOC line #$i";
            chomp($toc_line);
            $toc_line =~ /\S/ or last;
            $toc_line =~ /^([^,]+),(\d+),(\d+)(?:,(.*))?$/
                or die "Invalid TOC line #$i in data section: $toc_line";
            $toc{$1} = [$2, $3, $4];
        }
        my $pos = tell $fh;
        $toc{$_}[0] += $pos for keys %toc;


            # calculate the line number of data section
            my $data_pos = tell(DATA);
            seek DATA, 0, 0;
            my $pos = 0;
            while (1) {
                my $line = <DATA>;
                $pos += length($line);
                $data_linepos++;
                last if $pos >= $data_pos;
            }
            seek DATA, $data_pos, 0;

            \%toc;
        };
        if ($toc->{$_[1]}) {
            seek DATA, $toc->{$_[1]}[0], 0;
            read DATA, my($content), $toc->{$_[1]}[1];
            my ($order, $lineoffset) = split(';', $toc->{$_[1]}[2]);
            $content =~ s/^ //gm;
            $content = "# line ".($data_linepos + $order+1 + $lineoffset)." \"".__FILE__."\"\n" . $content;
            open my $fh, '<', \$content
                or die "DataPacker error loading $_[1]: $!";
            return $fh;
        }
        return;
    };
}
# END DATAPACK CODE

our $DATE = '2015-10-22'; # DATE
our $DIST = 'File-RsyBak'; # DIST
our $VERSION = '0.29'; # VERSION

use 5.010001;
use strict;
use warnings;

require Perinci::CmdLine::Classic;

Perinci::CmdLine::Classic->new(
    url => "/File/RsyBak/backup",
    program_name => "rsybak",
)->run;

# ABSTRACT: Backup files/directories with histories, using rsync
# PODNAME: rsybak

__END__

=pod

=encoding UTF-8

=head1 NAME

rsybak - Backup files/directories with histories, using rsync

=head1 VERSION

This document describes version 0.29 of rsybak (from Perl distribution File-RsyBak), released on 2015-10-22.

=head1 SYNOPSIS

Usage:

 % rsybak [options] <source> <target>

Examples:

 % rsybak /home/jajang/mydata /backup/jajang/mydata
 ERROR 500: Error: Can't create target directory : No such file or directory

=head1 COMPLETION

This script has shell tab completion capability with support for several
shells.

=head2 bash

To activate bash completion for this script, put:

 complete -C rsybak rsybak

in your bash startup (e.g. C<~/.bashrc>). Your next shell session will then
recognize tab completion for the command. Or, you can also directly execute the
line above in your shell to activate immediately.

It is recommended, however, that you install L<shcompgen> which allows you to
activate completion scripts for several kinds of scripts on multiple shells.
Some CPAN distributions (those that are built with
L<Dist::Zilla::Plugin::GenShellCompletion>) will even automatically enable shell
completion for their included scripts (using C<shcompgen>) at installation time,
so you can immadiately have tab completion.

=head2 tcsh

To activate tcsh completion for this script, put:

 complete rsybak 'p/*/`rsybak`/'

in your tcsh startup (e.g. C<~/.tcshrc>). Your next shell session will then
recognize tab completion for the command. Or, you can also directly execute the
line above in your shell to activate immediately.

It is also recommended to install C<shcompgen> (see above).

=head2 other shells

For fish and zsh, install C<shcompgen> as described above.

=head1 ENVIRONMENT

=head2 RSYBAK_OPT => str

Specify additional command-line options

=head1 CONFIGURATION FILE

This script can read configuration file, which by default is searched at C<~/.config/rsybak.conf>, C<~/rsybak.conf> or C</etc/rsybak.conf> (can be changed by specifying C<--config-path>). All found files will be read and merged.

To disable searching for configuration files, pass C<--no-config>.

Configuration file is in the format of L<IOD>, which is basically INI with some extra features. 

You can put multiple profiles in a single file by using section names like C<[profile=SOMENAME]>. Those sections will only be read if you specify the matching C<--config-profile SOMENAME>.

List of available configuration parameters:

 backup (see --no-backup)
 extra_dir (see --extra-dir)
 extra_rsync_opts (see --extra-rsync-opts)
 format (see --format)
 format_options (see --format-options)
 histories (see --histories)
 naked_res (see --naked-res)
 rotate (see --no-rotate)
 source (see --source)
 target (see --target)

=head1 FILES

~/.config/rsybak.conf

~/rsybak.conf

/etc/rsybak.conf

=head1 HOMEPAGE

Please visit the project's homepage at L<https://metacpan.org/release/File-RsyBak>.

=head1 SOURCE

Source repository is at L<https://github.com/perlancar/perl-File-RsyBak>.

=head1 BUGS

Please report any bugs or feature requests on the bugtracker website L<https://rt.cpan.org/Public/Dist/Display.html?Name=File-RsyBak>

When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.

=head1 AUTHOR

perlancar <perlancar@cpan.org>

=head1 COPYRIGHT AND LICENSE

This software is copyright (c) 2015 by perlancar@cpan.org.

This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.

=head1 OPTIONS

C<*> marks required options.

=head2 Configuration options

=over

=item B<--config-path>=I<filename>

Set path to configuration file.

Can be specified multiple times.

=item B<--config-profile>=I<s>

Set configuration profile to use.

=item B<--no-config>

Do not use any configuration file.

=back

=head2 Environment options

=over

=item B<--no-env>

Do not read environment for default options.

=back

=head2 Output options

=over

=item B<--format-options>=I<s>

Pass options to formatter.

=item B<--format>=I<s>

Choose output format, e.g. json, text.

Default value:

 undef

=item B<--json>

Equivalent to --format=json-pretty.

=item B<--naked-res>

When outputing as JSON, strip result envelope.

Default value:

 0

By default, when outputing as JSON, the full enveloped result is returned, e.g.:

    [200,"OK",[1,2,3],{"func.extra"=>4}]

The reason is so you can get the status (1st element), status message (2nd
element) as well as result metadata/extra result (4th element) instead of just
the result (3rd element). However, sometimes you want just the result, e.g. when
you want to pipe the result for more post-processing. In this case you can use
`--naked-res` so you just get:

    [1,2,3]


=back

=head2 Other options

=over

=item B<--extra-dir>

Whether to force creation of source directory in target.

If set to 1, then backup(source => '/a', target => '/backup/a') will create
another 'a' directory in target, i.e. /backup/a/current/a. Otherwise, contents
of a/ will be directly copied under /backup/a/current/.

Will always be set to 1 if source is more than one, but default to 0 if source
is a single directory. You can set this to 1 to so that behaviour when there is
a single source is the same as behaviour when there are several sources.


=item B<--extra-rsync-opts-json>=I<s>

Pass extra options to rsync command (JSON-encoded).

See C<--extra-rsync-opts>.

=item B<--extra-rsync-opts-yaml>=I<s>

Pass extra options to rsync command (YAML-encoded).

See C<--extra-rsync-opts>.

=item B<--extra-rsync-opts>=I<s@>

Pass extra options to rsync command.

Extra options to pass to rsync command when doing backup. Note that the options
will be shell quoted, , so you should pass it unquoted, e.g. ['--exclude',
'/Program Files'].


Can be specified multiple times.

=item B<--help>, B<-h>, B<-?>

Display help message and exit.

=item B<--histories-json>=I<s>

Histories/history levels (JSON-encoded).

See C<--histories>.

=item B<--histories-yaml>=I<s>

Histories/history levels (YAML-encoded).

See C<--histories>.

=item B<--histories>=I<s@>

Histories/history levels.

Default value:

 [-7,4,3]

Specifies number of backup histories to keep for level 1, 2, and so on. If
number is negative, specifies number of days to keep instead (regardless of
number of histories).


Can be specified multiple times.

=item B<--no-backup>

If backup=1 and rotate=0 then will only create new backup without rotating
histories.


=item B<--no-rotate>

If backup=0 and rotate=1 then will only do history rotating.


=item B<--source>=I<s>*

Director(y|ies) to backup.

=item B<--target>=I<s>*

Backup destination.

=item B<--version>, B<-v>

Display program's version and exit.

=back

=cut

__DATA__
Data::Section::Seekable v1
Algorithm/Dependency.pm,32,1864,0;0
Algorithm/Dependency/Item.pm,1933,420,1;116
Algorithm/Dependency/Ordered.pm,2393,1071,2;148
Algorithm/Dependency/Source.pm,3503,1872,3;206
Algorithm/Dependency/Source/File.pm,5419,1057,4;311
Algorithm/Dependency/Source/HoA.pm,6519,749,5;372
Algorithm/Dependency/Source/Invert.pm,7314,673,6;425
Algorithm/Dependency/Weight.pm,8026,1645,7;463
B/Hooks/EndOfScope.pm,9701,447,8;564
B/Hooks/EndOfScope/PP.pm,10181,1284,9;591
B/Hooks/EndOfScope/XS.pm,11498,635,10;640
Border/Style.pm,12157,98,11;678
Border/Style/Role.pm,12284,2788,12;687
Class/Inspector.pm,15099,5934,13;798
Class/Inspector/Functions.pm,21070,708,14;1095
Class/Method/Modifiers.pm,21812,4801,15;1142
Clone/PP.pm,26633,1884,16;1331
Color/ANSI/Util.pm,28544,10788,17;1402
Color/RGB/Util.pm,39358,4182,18;1707
Color/Theme.pm,43563,97,19;1862
Color/Theme/Role.pm,43688,3009,20;1871
Color/Theme/Role/ANSI.pm,46730,2464,21;1991
Color/Theme/Util.pm,49222,1329,22;2077
Complete.pm,50571,93,23;2128
Complete/Bash.pm,50689,16756,24;2137
Complete/Env.pm,67469,1693,25;2636
Complete/File.pm,69187,6373,26;2702
Complete/Fish.pm,75585,3416,27;2910
Complete/Getopt/Long.pm,79033,18426,28;3042
Complete/Path.pm,97484,9057,29;3569
Complete/Setting.pm,106569,490,30;3857
Complete/Tcsh.pm,107084,2757,31;3876
Complete/Util.pm,109866,9957,32;3981
Complete/Zsh.pm,119847,2764,33;4352
Config/IOD/Base.pm,122638,10732,34;4457
Config/IOD/Expr.pm,133397,1287,35;4857
Config/IOD/Reader.pm,134713,5139,36;4942
Data/Check/Structure.pm,139884,3555,37;5109
Data/Clean/Base.pm,143466,6917,38;5274
Data/Clean/FromJSON.pm,150414,475,39;5505
Data/Clean/JSON.pm,150916,683,40;5533
Data/Dmp.pm,151619,3556,41;5566
Data/Dump.pm,155196,12066,42;5719
Data/Dump/FilterContext.pm,167297,1740,43;6252
Data/Dump/Filtered.pm,169067,812,44;6346
Data/Dump/OneLine.pm,169908,325,45;6379
Data/Dump/Partial.pm,170262,5169,46;6400
Data/Dump/Trace.pm,175458,6339,47;6552
Data/Format/Pretty.pm,181827,921,48;6818
Data/Format/Pretty/CompactJSON.pm,182790,672,49;6868
Data/Format/Pretty/Console.pm,183500,12205,50;6904
Data/Format/Pretty/HTML.pm,195740,2897,51;7340
Data/Format/Pretty/JSON.pm,198672,1061,52;7462
Data/Format/Pretty/SimpleText.pm,199774,480,53;7508
Data/Format/Pretty/Text.pm,200289,474,54;7535
Data/ModeMerge.pm,200789,10687,55;7562
Data/ModeMerge/Config.pm,211509,2140,56;7886
Data/ModeMerge/Mode/ADD.pm,213684,1373,57;7957
Data/ModeMerge/Mode/Base.pm,215093,16703,58;8026
Data/ModeMerge/Mode/CONCAT.pm,231834,442,59;8555
Data/ModeMerge/Mode/DELETE.pm,232314,1218,60;8583
Data/ModeMerge/Mode/KEEP.pm,233568,1174,61;8658
Data/ModeMerge/Mode/NORMAL.pm,234780,1501,62;8726
Data/ModeMerge/Mode/SUBTRACT.pm,236321,2064,63;8819
Data/Sah.pm,238405,4381,64;8911
Data/Sah/Compiler.pm,242815,17407,65;9078
Data/Sah/Compiler/Prog.pm,260256,20437,66;9680
Data/Sah/Compiler/Prog/TH.pm,280730,3001,67;10366
Data/Sah/Compiler/Prog/TH/all.pm,283772,534,68;10489
Data/Sah/Compiler/Prog/TH/any.pm,284347,532,69;10521
Data/Sah/Compiler/TH.pm,284911,1247,70;10553
Data/Sah/Compiler/TextResultRole.pm,286202,873,71;10619
Data/Sah/Compiler/human.pm,287110,12293,72;10670
Data/Sah/Compiler/human/TH.pm,299441,1082,73;11115
Data/Sah/Compiler/human/TH/Comparable.pm,300572,688,74;11181
Data/Sah/Compiler/human/TH/HasElems.pm,301307,1964,75;11213
Data/Sah/Compiler/human/TH/Sortable.pm,303318,1543,76;11285
Data/Sah/Compiler/human/TH/all.pm,304903,1852,77;11352
Data/Sah/Compiler/human/TH/any.pm,306797,1801,78;11432
Data/Sah/Compiler/human/TH/array.pm,308642,2853,79;11511
Data/Sah/Compiler/human/TH/bool.pm,311538,1152,80;11622
Data/Sah/Compiler/human/TH/buf.pm,312732,472,81;11680
Data/Sah/Compiler/human/TH/cistr.pm,313248,266,82;11710
Data/Sah/Compiler/human/TH/code.pm,313557,470,83;11728
Data/Sah/Compiler/human/TH/date.pm,314070,564,84;11757
Data/Sah/Compiler/human/TH/duration.pm,314681,482,85;11787
Data/Sah/Compiler/human/TH/float.pm,315207,2136,86;11815
Data/Sah/Compiler/human/TH/hash.pm,317386,8473,87;11912
Data/Sah/Compiler/human/TH/int.pm,325901,1741,88;12236
Data/Sah/Compiler/human/TH/num.pm,327684,568,89;12315
Data/Sah/Compiler/human/TH/obj.pm,328294,901,90;12345
Data/Sah/Compiler/human/TH/re.pm,329236,516,91;12396
Data/Sah/Compiler/human/TH/str.pm,329794,2306,92;12427
Data/Sah/Compiler/human/TH/undef.pm,332144,528,93;12532
Data/Sah/Compiler/js.pm,332704,4375,94;12563
Data/Sah/Compiler/js/TH.pm,337114,1244,95;12802
Data/Sah/Compiler/js/TH/all.pm,338397,312,96;12845
Data/Sah/Compiler/js/TH/any.pm,338748,289,97;12867
Data/Sah/Compiler/js/TH/array.pm,339078,4205,98;12888
Data/Sah/Compiler/js/TH/bool.pm,343323,2306,99;13020
Data/Sah/Compiler/js/TH/buf.pm,345668,288,100;13103
Data/Sah/Compiler/js/TH/cistr.pm,345997,3457,101;13122
Data/Sah/Compiler/js/TH/code.pm,349494,457,102;13245
Data/Sah/Compiler/js/TH/date.pm,349991,4677,103;13272
Data/Sah/Compiler/js/TH/float.pm,354709,2966,104;13428
Data/Sah/Compiler/js/TH/hash.pm,357715,15189,105;13551
Data/Sah/Compiler/js/TH/int.pm,372943,891,106;14039
Data/Sah/Compiler/js/TH/num.pm,373873,2142,107;14084
Data/Sah/Compiler/js/TH/obj.pm,376054,842,108;14172
Data/Sah/Compiler/js/TH/re.pm,376934,453,109;14217
Data/Sah/Compiler/js/TH/str.pm,377426,5360,110;14245
Data/Sah/Compiler/js/TH/undef.pm,382827,469,111;14429
Data/Sah/Compiler/perl.pm,383330,7811,112;14456
Data/Sah/Compiler/perl/TH.pm,391178,1296,113;14783
Data/Sah/Compiler/perl/TH/all.pm,392515,316,114;14831
Data/Sah/Compiler/perl/TH/any.pm,392872,316,115;14853
Data/Sah/Compiler/perl/TH/array.pm,393231,4048,116;14875
Data/Sah/Compiler/perl/TH/bool.pm,397321,2352,117;15006
Data/Sah/Compiler/perl/TH/buf.pm,399714,292,118;15090
Data/Sah/Compiler/perl/TH/cistr.pm,400049,3613,119;15109
Data/Sah/Compiler/perl/TH/code.pm,403704,456,120;15242
Data/Sah/Compiler/perl/TH/date.pm,404202,6502,121;15269
Data/Sah/Compiler/perl/TH/duration.pm,410750,4686,122;15451
Data/Sah/Compiler/perl/TH/float.pm,415479,6295,123;15570
Data/Sah/Compiler/perl/TH/hash.pm,421816,13846,124;15754
Data/Sah/Compiler/perl/TH/int.pm,435703,1065,125;16194
Data/Sah/Compiler/perl/TH/num.pm,436809,2059,126;16245
Data/Sah/Compiler/perl/TH/obj.pm,438909,874,127;16321
Data/Sah/Compiler/perl/TH/re.pm,439823,523,128;16367
Data/Sah/Compiler/perl/TH/str.pm,440387,4819,129;16396
Data/Sah/Compiler/perl/TH/undef.pm,445249,453,130;16563
Data/Sah/Human.pm,445728,667,131;16590
Data/Sah/JS.pm,446418,1709,132;16625
Data/Sah/Lang.pm,448152,261,133;16703
Data/Sah/Lang/fr_FR.pm,448444,1563,134;16724
Data/Sah/Lang/id_ID.pm,450038,8103,135;16830
Data/Sah/Lang/zh_CN.pm,458172,1452,136;17224
Data/Sah/Normalize.pm,459654,6073,137;17330
Data/Sah/Type/BaseType.pm,465761,2139,138;17511
Data/Sah/Type/Comparable.pm,467936,649,139;17617
Data/Sah/Type/HasElems.pm,468619,2481,140;17648
Data/Sah/Type/Sortable.pm,471134,1632,141;17754
Data/Sah/Type/all.pm,472795,380,142;17825
Data/Sah/Type/any.pm,473204,380,143;17846
Data/Sah/Type/array.pm,473615,643,144;17867
Data/Sah/Type/bool.pm,474288,414,145;17897
Data/Sah/Type/buf.pm,474731,179,146;17920
Data/Sah/Type/cistr.pm,474941,181,147;17934
Data/Sah/Type/code.pm,475152,185,148;17948
Data/Sah/Type/date.pm,475367,300,149;17962
Data/Sah/Type/duration.pm,475701,232,150;17980
Data/Sah/Type/float.pm,475964,802,151;17996
Data/Sah/Type/hash.pm,476796,3350,152;18039
Data/Sah/Type/int.pm,480175,512,153;18170
Data/Sah/Type/num.pm,480716,256,154;18196
Data/Sah/Type/obj.pm,481001,449,155;18212
Data/Sah/Type/re.pm,481478,224,156;18238
Data/Sah/Type/str.pm,481731,708,157;18253
Data/Sah/Type/undef.pm,482470,167,158;18289
Data/Sah/Util/Func.pm,482667,331,159;18301
Data/Sah/Util/Role.pm,483028,3479,160;18325
Data/Sah/Util/Type.pm,486537,3113,161;18439
Data/Sah/Util/Type/Date.pm,489685,5074,162;18557
Data/Sah/Util/TypeX.pm,494790,339,163;18703
Devel/GlobalDestruction.pm,495164,665,164;18729
Dist/CheckConflicts.pm,495860,5023,165;18763
Exporter/Lite.pm,500908,1888,166;18959
File/Flock/Retry.pm,502824,1775,167;19032
File/HomeDir.pm,504623,6297,168;19132
File/HomeDir/Darwin.pm,510951,2054,169;19406
File/HomeDir/Darwin/Carbon.pm,513043,2564,170;19524
File/HomeDir/Darwin/Cocoa.pm,515644,2079,171;19676
File/HomeDir/Driver.pm,517754,231,172;19794
File/HomeDir/FreeDesktop.pm,518021,1824,173;19812
File/HomeDir/MacOS9.pm,519876,1282,174;19886
File/HomeDir/Test.pm,521187,1608,175;19968
File/HomeDir/Unix.pm,522824,1491,176;20056
File/HomeDir/Windows.pm,524347,2456,177;20175
File/RsyBak.pm,526826,11669,178;20317
File/RsyBak/Packed.pm,538525,107,179;20676
File/Slurp/Tiny.pm,538659,2063,180;20686
File/Which.pm,540744,2227,181;20759
File/Write/Rotate.pm,543000,11048,182;20873
Function/Fallback/CoreOrPP.pm,554086,1609,183;21290
Getopt/Long/Negate/EN.pm,555728,811,184;21374
Getopt/Long/Util.pm,556567,7487,185;21404
HTML/Entities.pm,564079,8447,186;21678
HTML/Filter.pm,572549,500,187;22018
HTML/HeadParser.pm,573076,3428,188;22041
HTML/LinkExtor.pm,576530,1467,189;22192
HTML/Parser.pm,578020,2602,190;22267
HTML/PullParser.pm,580649,2323,191;22390
HTML/Tagset.pm,582995,4076,192;22498
HTML/TokeParser.pm,587098,3234,193;22693
HTTP/Tiny.pm,590353,36140,194;22848
HTTP/Tiny/UNIX.pm,626519,2136,195;24046
IO/Socket/UNIX/Util.pm,628686,1849,196;24144
JSON.pm,630551,71912,197;24225
JSON/Color.pm,702485,5115,198;26524
JSON/PP.pm,707619,41741,199;26729
JSON/PP/Boolean.pm,749387,43,200;28283
LWP.pm,749445,127,201;28290
LWP/Authen/Basic.pm,749600,2007,202;28302
LWP/Authen/Digest.pm,751636,1965,203;28365
LWP/Authen/Ntlm.pm,753628,2119,204;28439
LWP/ConnCache.pm,755772,3375,205;28526
LWP/Debug.pm,759168,1159,206;28696
LWP/DebugFile.pm,760352,33,207;28764
LWP/MemberMixin.pm,760412,195,208;28768
LWP/Protocol.pm,760631,4320,209;28783
LWP/Protocol/GHTTP.pm,764981,1352,210;28969
LWP/Protocol/cpan.pm,766362,1303,211;29031
LWP/Protocol/data.pm,767694,1183,212;29099
LWP/Protocol/file.pm,768906,3475,213;29148
LWP/Protocol/ftp.pm,772409,15283,214;29279
LWP/Protocol/gopher.pm,787723,4821,215;29780
LWP/Protocol/http.pm,792573,12139,216;29973
LWP/Protocol/http/SocketUnixAlt.pm,804755,6636,217;30435
LWP/Protocol/loopback.pm,811424,627,218;30704
LWP/Protocol/mailto.pm,812082,4304,219;30730
LWP/Protocol/nntp.pm,816415,3153,220;30906
LWP/Protocol/nogo.pm,819597,409,221;31032
LWP/RobotUA.pm,820029,3898,222;31051
LWP/Simple.pm,823949,1955,223;31227
LWP/UserAgent.pm,825929,28316,224;31323
Lingua/EN/Numbers/Ordinate.pm,854283,724,225;32321
Lingua/EN/PluralToSingular.pm,855045,4715,226;32360
Locale/Messages.pm,859787,7938,227;32673
Locale/Recode.pm,867750,2671,228;33083
Locale/Recode/_Aliases.pm,870455,23009,229;33229
Locale/Recode/_Conversions.pm,893502,8557,230;33915
Locale/RecodeData.pm,902088,534,231;34278
Locale/RecodeData/ASMO_449.pm,902660,12115,232;34320
Locale/RecodeData/ATARI_ST.pm,914813,15075,233;35009
Locale/RecodeData/ATARI_ST_EURO.pm,929931,15080,234;35834
Locale/RecodeData/CP10007.pm,945048,15082,235;36659
Locale/RecodeData/CP1250.pm,960166,14958,236;37484
Locale/RecodeData/CP1251.pm,975160,15054,237;38304
Locale/RecodeData/CP1252.pm,990250,14958,238;39128
Locale/RecodeData/CP1253.pm,1005244,14686,239;39948
Locale/RecodeData/CP1254.pm,1019966,14912,240;40756
Locale/RecodeData/CP1256.pm,1034914,15089,241;41574
Locale/RecodeData/CP1257.pm,1050039,14797,242;42399
Locale/RecodeData/CSN_369103.pm,1064876,15009,243;43212
Locale/RecodeData/CWI.pm,1079918,15262,244;44037
Locale/RecodeData/DEC_MCS.pm,1095217,14661,245;44862
Locale/RecodeData/EBCDIC_AT_DE.pm,1109920,12835,246;45672
Locale/RecodeData/EBCDIC_AT_DE_A.pm,1122799,12742,247;46401
Locale/RecodeData/EBCDIC_CA_FR.pm,1135583,13314,248;47125
Locale/RecodeData/EBCDIC_DK_NO.pm,1148939,12835,249;47875
Locale/RecodeData/EBCDIC_DK_NO_A.pm,1161818,12742,250;48604
Locale/RecodeData/EBCDIC_ES.pm,1174599,12828,251;49328
Locale/RecodeData/EBCDIC_ES_A.pm,1187468,12735,252;50057
Locale/RecodeData/EBCDIC_ES_S.pm,1200244,12822,253;50781
Locale/RecodeData/EBCDIC_FI_SE.pm,1213108,12847,254;51510
Locale/RecodeData/EBCDIC_FI_SE_A.pm,1225999,12742,255;52239
Locale/RecodeData/EBCDIC_FR.pm,1238780,12836,256;52963
Locale/RecodeData/EBCDIC_IS_FRISS.pm,1251661,12493,257;53692
Locale/RecodeData/EBCDIC_IT.pm,1264193,12840,258;54406
Locale/RecodeData/EBCDIC_PT.pm,1277072,12828,259;55135
Locale/RecodeData/EBCDIC_UK.pm,1289939,12820,260;55864
Locale/RecodeData/EBCDIC_US.pm,1302798,12812,261;56593
Locale/RecodeData/ECMA_CYRILLIC.pm,1315653,15016,262;57322
Locale/RecodeData/GEORGIAN_ACADEMY.pm,1330715,15235,263;58147
Locale/RecodeData/GEORGIAN_PS.pm,1345991,15226,264;58972
Locale/RecodeData/GOST_19768_74.pm,1361260,14368,265;59797
Locale/RecodeData/GREEK7.pm,1375664,12212,266;60594
Locale/RecodeData/GREEK7_OLD.pm,1387916,12310,267;61288
Locale/RecodeData/GREEK_CCITT.pm,1400267,12194,268;61984
Locale/RecodeData/HP_ROMAN8.pm,1412500,14997,269;62677
Locale/RecodeData/IBM037.pm,1427533,15005,270;63501
Locale/RecodeData/IBM038.pm,1442574,12801,271;64326
Locale/RecodeData/IBM1004.pm,1455412,14863,272;65055
Locale/RecodeData/IBM1026.pm,1470312,15010,273;65871
Locale/RecodeData/IBM1047.pm,1485359,15006,274;66696
Locale/RecodeData/IBM256.pm,1500401,15021,275;67521
Locale/RecodeData/IBM273.pm,1515458,15009,276;68346
Locale/RecodeData/IBM274.pm,1530503,12821,277;69171
Locale/RecodeData/IBM275.pm,1543360,12829,278;69900
Locale/RecodeData/IBM277.pm,1556225,15009,279;70629
Locale/RecodeData/IBM278.pm,1571270,15009,280;71454
Locale/RecodeData/IBM280.pm,1586315,15009,281;72279
Locale/RecodeData/IBM281.pm,1601360,12821,282;73104
Locale/RecodeData/IBM284.pm,1614217,15009,283;73833
Locale/RecodeData/IBM285.pm,1629262,15009,284;74658
Locale/RecodeData/IBM290.pm,1644307,13990,285;75483
Locale/RecodeData/IBM297.pm,1658333,15009,286;76247
Locale/RecodeData/IBM420.pm,1673378,14955,287;77072
Locale/RecodeData/IBM423.pm,1688369,14803,288;77887
Locale/RecodeData/IBM424.pm,1703208,14116,289;78702
Locale/RecodeData/IBM437.pm,1717360,15253,290;79488
Locale/RecodeData/IBM500.pm,1732649,15005,291;80313
Locale/RecodeData/IBM850.pm,1747690,15125,292;81138
Locale/RecodeData/IBM851.pm,1762851,15098,293;81963
Locale/RecodeData/IBM852.pm,1777985,15121,294;82787
Locale/RecodeData/IBM855.pm,1793142,15125,295;83612
Locale/RecodeData/IBM857.pm,1808303,15052,296;84437
Locale/RecodeData/IBM860.pm,1823391,15249,297;85259
Locale/RecodeData/IBM861.pm,1838676,15253,298;86084
Locale/RecodeData/IBM862.pm,1853965,15253,299;86909
Locale/RecodeData/IBM863.pm,1869254,15253,300;87734
Locale/RecodeData/IBM864.pm,1884543,15227,301;88559
Locale/RecodeData/IBM865.pm,1899806,15253,302;89378
Locale/RecodeData/IBM866.pm,1915095,15213,303;90203
Locale/RecodeData/IBM868.pm,1930344,14654,304;91028
Locale/RecodeData/IBM869.pm,1945034,14926,305;91828
Locale/RecodeData/IBM870.pm,1959996,14752,306;92644
Locale/RecodeData/IBM871.pm,1974784,15005,307;93458
Locale/RecodeData/IBM874.pm,1989825,14676,308;94283
Locale/RecodeData/IBM875.pm,2004537,14864,309;95077
Locale/RecodeData/IBM880.pm,2019437,14799,310;95895
Locale/RecodeData/IBM891.pm,2034272,12061,311;96710
Locale/RecodeData/IBM903.pm,2046369,12061,312;97407
Locale/RecodeData/IBM904.pm,2058466,12130,313;98104
Locale/RecodeData/IBM905.pm,2070632,14798,314;98804
Locale/RecodeData/IBM918.pm,2085466,14503,315;99620
Locale/RecodeData/IEC_P27_1.pm,2100008,15212,316;100419
Locale/RecodeData/INIS.pm,2115254,11812,317;101244
Locale/RecodeData/INIS_8.pm,2127102,11237,318;101928
Locale/RecodeData/INIS_CYRILLIC.pm,2138382,12188,319;102569
Locale/RecodeData/ISO_10367_BOX.pm,2150613,13587,320;103254
Locale/RecodeData/ISO_2033_1983.pm,2164243,10580,321;104012
Locale/RecodeData/ISO_5427.pm,2174861,12319,322;104629
Locale/RecodeData/ISO_5427_EXT.pm,2187222,11235,323;105326
Locale/RecodeData/ISO_5428.pm,2198495,12004,324;105971
Locale/RecodeData/ISO_8859_1.pm,2210539,4631,325;106647
Locale/RecodeData/ISO_8859_10.pm,2215211,15014,326;106951
Locale/RecodeData/ISO_8859_11.pm,2230266,14342,327;107776
Locale/RecodeData/ISO_8859_13.pm,2244649,15026,328;108561
Locale/RecodeData/ISO_8859_14.pm,2259716,15098,329;109386
Locale/RecodeData/ISO_8859_15.pm,2274855,15014,330;110211
Locale/RecodeData/ISO_8859_16.pm,2289910,15022,331;111036
Locale/RecodeData/ISO_8859_2.pm,2304972,15009,332;111861
Locale/RecodeData/ISO_8859_3.pm,2320021,14848,333;112686
Locale/RecodeData/ISO_8859_4.pm,2334909,15009,334;113504
Locale/RecodeData/ISO_8859_5.pm,2349958,15013,335;114329
Locale/RecodeData/ISO_8859_6.pm,2365011,13974,336;115154
Locale/RecodeData/ISO_8859_7.pm,2379025,14883,337;115934
Locale/RecodeData/ISO_8859_8.pm,2393948,14193,338;116753
Locale/RecodeData/ISO_8859_9.pm,2408181,15009,339;117542
Locale/RecodeData/KOI8_R.pm,2423226,15229,340;118367
Locale/RecodeData/KOI8_RU.pm,2438492,15190,341;119192
Locale/RecodeData/KOI8_T.pm,2453718,14636,342;120017
Locale/RecodeData/KOI8_U.pm,2468390,15197,343;120823
Locale/RecodeData/KOI_8.pm,2483622,13509,344;121648
Locale/RecodeData/LATIN_GREEK.pm,2497172,12155,345;122408
Locale/RecodeData/LATIN_GREEK_1.pm,2509370,12120,346;123104
Locale/RecodeData/MACARABIC.pm,2521529,14414,347;123801
Locale/RecodeData/MACCROATIAN.pm,2535984,15103,348;124600
Locale/RecodeData/MACCYRILLIC.pm,2551128,15090,349;125424
Locale/RecodeData/MACGREEK.pm,2566256,15044,350;126249
Locale/RecodeData/MACHEBREW.pm,2581339,14098,351;127073
Locale/RecodeData/MACICELAND.pm,2595477,15090,352;127856
Locale/RecodeData/MACINTOSH.pm,2610606,15136,353;128680
Locale/RecodeData/MACROMANIA.pm,2625782,15106,354;129505
Locale/RecodeData/MACTHAI.pm,2640925,15336,355;130329
Locale/RecodeData/MACTURKISH.pm,2656301,15071,356;131148
Locale/RecodeData/MACUKRAINE.pm,2671412,15085,357;131971
Locale/RecodeData/MAC_IS.pm,2686533,15067,358;132796
Locale/RecodeData/MAC_SAMI.pm,2701638,15095,359;133619
Locale/RecodeData/MAC_UK.pm,2716769,15081,360;134444
Locale/RecodeData/NATS_DANO.pm,2731889,12128,361;135269
Locale/RecodeData/NATS_SEFI.pm,2744056,12120,362;135966
Locale/RecodeData/NEXTSTEP.pm,2756214,15029,363;136663
Locale/RecodeData/SAMI_WS2.pm,2771281,14886,364;137486
Locale/RecodeData/TIS_620.pm,2786204,14411,365;138304
Locale/RecodeData/US_ASCII.pm,2800653,816,366;139088
Locale/RecodeData/UTF_8.pm,2801504,3052,367;139134
Locale/RecodeData/VISCII.pm,2804592,15389,368;139268
Locale/RecodeData/_Encode.pm,2820018,964,369;140093
Locale/TextDomain.pm,2821011,7048,370;140146
Locale/TextDomain/UTF8.pm,2828093,506,371;140491
Locale/Util.pm,2828622,21462,372;140518
Locale/gettext_dumb.pm,2850115,5589,373;141444
Locale/gettext_pp.pm,2855733,20371,374;141634
Locale/gettext_xs.pm,2876133,4198,375;142427
Log/Any.pm,2880350,2421,376;142608
Log/Any/Adapter.pm,2882798,367,377;142714
Log/Any/Adapter/Base.pm,2883197,772,378;142743
Log/Any/Adapter/File.pm,2884001,1791,379;142780
Log/Any/Adapter/Log4perl.pm,2885828,850,380;142844
Log/Any/Adapter/Null.pm,2886710,350,381;142886
Log/Any/Adapter/Screen.pm,2887094,2747,382;142908
Log/Any/Adapter/Stderr.pm,2889875,1197,383;143020
Log/Any/Adapter/Stdout.pm,2891106,1197,384;143069
Log/Any/Adapter/Test.pm,2892335,4292,385;143118
Log/Any/Adapter/Util.pm,2896659,3025,386;143292
Log/Any/App.pm,2899707,37231,387;143440
Log/Any/IfLOG.pm,2936963,1357,388;144538
Log/Any/Manager.pm,2938347,5072,389;144603
Log/Any/Proxy.pm,2943444,2492,390;144792
Log/Any/Proxy/Test.pm,2945966,475,391;144881
Log/Any/Test.pm,2946465,275,392;144911
Log/Dispatch.pm,2946764,5903,393;144927
Log/Dispatch/ApacheLog.pm,2952701,1089,394;145209
Log/Dispatch/ArrayWithLimits.pm,2953830,890,395;145270
Log/Dispatch/Base.pm,2954749,864,396;145313
Log/Dispatch/Code.pm,2955642,652,397;145365
Log/Dispatch/Dir.pm,2956322,5622,398;145407
Log/Dispatch/Email.pm,2961974,2359,399;145612
Log/Dispatch/Email/MIMELite.pm,2964372,630,400;145720
Log/Dispatch/Email/MailSend.pm,2965041,784,401;145757
Log/Dispatch/Email/MailSender.pm,2965866,2048,402;145801
Log/Dispatch/Email/MailSendmail.pm,2967957,622,403;145885
Log/Dispatch/File.pm,2968608,3703,404;145921
Log/Dispatch/File/Locked.pm,2972347,484,405;146093
Log/Dispatch/FileWriteRotate.pm,2972871,977,406;146123
Log/Dispatch/Handle.pm,2973879,726,407;146171
Log/Dispatch/Null.pm,2974634,368,408;146212
Log/Dispatch/Output.pm,2975033,3848,409;146241
Log/Dispatch/Screen.pm,2978912,1048,410;146419
Log/Dispatch/Syslog.pm,2979991,2497,411;146477
Log/Log4perl.pm,2982512,13325,412;146596
Log/Log4perl/Appender.pm,2995870,5408,413;147094
Log/Log4perl/Appender/Buffer.pm,3001318,2315,414;147321
Log/Log4perl/Appender/DBI.pm,3003670,7150,415;147427
Log/Log4perl/Appender/File.pm,3010858,7352,416;147707
Log/Log4perl/Appender/Limit.pm,3018249,3445,417;147994
Log/Log4perl/Appender/RRDs.pm,3021732,751,418;148145
Log/Log4perl/Appender/Screen.pm,3022523,687,419;148185
Log/Log4perl/Appender/ScreenColoredLevels.pm,3023263,1633,420;148227
Log/Log4perl/Appender/Socket.pm,3024936,1981,421;148297
Log/Log4perl/Appender/String.pm,3026957,599,422;148387
Log/Log4perl/Appender/Synchronized.pm,3027602,1642,423;148426
Log/Log4perl/Appender/TestArrayBuffer.pm,3029293,428,424;148500
Log/Log4perl/Appender/TestBuffer.pm,3029765,1402,425;148519
Log/Log4perl/Appender/TestFileCreeper.pm,3031216,418,426;148602
Log/Log4perl/Catalyst.pm,3031667,3471,427;148628
Log/Log4perl/Config.pm,3035169,22897,428;148775
Log/Log4perl/Config/BaseConfigurator.pm,3058114,2716,429;149570
Log/Log4perl/Config/DOMConfigurator.pm,3060877,12963,430;149692
Log/Log4perl/Config/PropertyConfigurator.pm,3073892,3053,431;150161
Log/Log4perl/Config/Watch.pm,3076982,4454,432;150285
Log/Log4perl/DateFormat.pm,3081471,4908,433;150463
Log/Log4perl/Filter.pm,3086410,1486,434;150664
Log/Log4perl/Filter/Boolean.pm,3087935,1781,435;150742
Log/Log4perl/Filter/LevelMatch.pm,3089758,1120,436;150831
Log/Log4perl/Filter/LevelRange.pm,3090920,1267,437;150883
Log/Log4perl/Filter/MDC.pm,3092222,664,438;150937
Log/Log4perl/Filter/StringMatch.pm,3092929,1355,439;150975
Log/Log4perl/InternalDebug.pm,3094322,1093,440;151034
Log/Log4perl/JavaMap.pm,3095447,1901,441;151097
Log/Log4perl/JavaMap/ConsoleAppender.pm,3097396,762,442;151158
Log/Log4perl/JavaMap/FileAppender.pm,3098203,1681,443;151193
Log/Log4perl/JavaMap/JDBCAppender.pm,3099929,1743,444;151247
Log/Log4perl/JavaMap/NTEventLogAppender.pm,3101723,616,445;151303
Log/Log4perl/JavaMap/RollingFileAppender.pm,3102391,2238,446;151335
Log/Log4perl/JavaMap/SyslogAppender.pm,3104676,949,447;151410
Log/Log4perl/JavaMap/TestBuffer.pm,3105668,386,448;151453
Log/Log4perl/Layout.pm,3106085,479,449;151471
Log/Log4perl/Layout/NoopLayout.pm,3106606,346,450;151502
Log/Log4perl/Layout/PatternLayout.pm,3106997,13624,451;151528
Log/Log4perl/Layout/PatternLayout/Multiline.pm,3120676,537,452;151999
Log/Log4perl/Layout/SimpleLayout.pm,3121257,563,453;152025
Log/Log4perl/Level.pm,3121850,3795,454;152060
Log/Log4perl/Logger.pm,3125676,22552,455;152239
Log/Log4perl/MDC.pm,3148256,611,456;153143
Log/Log4perl/NDC.pm,3148895,629,457;153190
Log/Log4perl/Resurrector.pm,3149560,2131,458;153235
Log/Log4perl/Util.pm,3151720,1335,459;153335
Log/Log4perl/Util/Semaphore.pm,3153094,4172,460;153400
Log/Log4perl/Util/TimeTracker.pm,3157307,2363,461;153570
Method/Generate/Accessor.pm,3159706,19704,462;153687
Method/Generate/BuildAll.pm,3179446,931,463;154347
Method/Generate/Constructor.pm,3180416,7706,464;154383
Method/Generate/DemolishAll.pm,3188161,1330,465;154639
Method/Inliner.pm,3189517,1401,466;154690
Mo.pm,3190932,563,467;154741
Mo/Golf.pm,3191514,7517,468;154744
Mo/Inline.pm,3199052,2045,469;154961
Mo/Moose.pm,3201117,467,470;155047
Mo/Mouse.pm,3201604,497,471;155050
Mo/build.pm,3202121,215,472;155053
Mo/builder.pm,3202358,303,473;155056
Mo/chain.pm,3202681,183,474;155059
Mo/coerce.pm,3202885,296,475;155062
Mo/default.pm,3203203,400,476;155065
Mo/exporter.pm,3203626,140,477;155068
Mo/import.pm,3203787,151,478;155071
Mo/importer.pm,3203961,171,479;155074
Mo/is.pm,3204149,198,480;155077
Mo/nonlazy.pm,3204369,94,481;155080
Mo/option.pm,3204484,225,482;155083
Mo/required.pm,3204732,304,483;155086
Mo/xs.pm,3205053,226,484;155089
Module/Implementation.pm,3205312,3386,485;155092
Module/List.pm,3208721,2572,486;155233
Module/Path/More.pm,3211321,4810,487;155322
Module/Runtime.pm,3216157,3939,488;155515
Monkey/Patch/Action.pm,3220127,1545,489;155681
Monkey/Patch/Action/Handle.pm,3221710,2833,490;155743
Moo.pm,3224558,6979,491;155857
Moo/HandleMoose.pm,3231564,7010,492;156083
Moo/HandleMoose/FakeMetaClass.pm,3238615,920,493;156294
Moo/HandleMoose/_TypeMap.pm,3239571,1652,494;156326
Moo/Object.pm,3241245,2009,495;156401
Moo/Role.pm,3243274,11633,496;156479
Moo/_Utils.pm,3254929,3410,497;156881
Moo/_mro.pm,3258359,124,498;157008
Moo/_strictures.pm,3258510,290,499;157018
Moo/sification.pm,3258826,710,500;157036
PERLANCAR/File/HomeDir.pm,3259570,798,501;157068
Package/MoreUtil.pm,3260396,2070,502;157107
Package/Stash.pm,3262491,896,503;157206
Package/Stash/PP.pm,3263415,10746,504;157247
Params/Util.pm,3274184,7232,505;157631
Params/Validate.pm,3281443,1200,506;157964
Params/Validate/Constants.pm,3282680,611,507;158032
Params/Validate/PP.pm,3283321,18326,508;158071
Params/Validate/XS.pm,3301677,993,509;158751
Parse/VarName.pm,3302695,1624,510;158802
Perinci/Access.pm,3304345,3061,511;158878
Perinci/Access/Base.pm,3307437,960,512;158981
Perinci/Access/HTTP/Client.pm,3308435,7806,513;159027
Perinci/Access/Lite.pm,3316272,6557,514;159283
Perinci/Access/Perl.pm,3322860,706,515;159474
Perinci/Access/Schemeless.pm,3323603,25893,516;159515
Perinci/Access/Simple/Client.pm,3349536,10150,517;160469
Perinci/AccessUtil.pm,3359716,2450,518;160785
Perinci/CmdLine/Base.pm,3362198,39877,519;160873
Perinci/CmdLine/Classic.pm,3402110,21224,520;162130
Perinci/CmdLine/Classic/ColorTheme/Default.pm,3423388,971,521;162856
Perinci/CmdLine/Classic/Role/Help.pm,3424404,14700,522;162902
Perinci/CmdLine/Help.pm,3439136,6668,523;163377
Perinci/CmdLine/Lite.pm,3445836,11373,524;163592
Perinci/CmdLine/Util/Config.pm,3457248,4885,525;164003
Perinci/Object.pm,3462159,984,526;164175
Perinci/Object/EnvResult.pm,3463179,1591,527;164227
Perinci/Object/EnvResultMulti.pm,3464811,1060,528;164312
Perinci/Object/Function.pm,3465906,1181,529;164362
Perinci/Object/Metadata.pm,3467122,2542,530;164420
Perinci/Object/Package.pm,3469698,222,531;164548
Perinci/Object/ResMeta.pm,3469954,222,532;164565
Perinci/Object/Variable.pm,3470211,224,533;164582
Perinci/Result/Format.pm,3470468,5351,534;164599
Perinci/Result/Format/Lite.pm,3475857,5922,535;164769
Perinci/Sub/CoerceArgs.pm,3481813,12033,536;164958
Perinci/Sub/Complete.pm,3493878,36097,537;165307
Perinci/Sub/ConvertArgs/Argv.pm,3530015,2870,538;166247
Perinci/Sub/ConvertArgs/Array.pm,3532926,2020,539;166359
Perinci/Sub/DepChecker.pm,3534980,5057,540;166439
Perinci/Sub/GetArgs/Argv.pm,3540073,34808,541;166628
Perinci/Sub/GetArgs/Array.pm,3574918,3345,542;167572
Perinci/Sub/Normalize.pm,3578296,4905,543;167694
Perinci/Sub/To/CLIDocData.pm,3583238,15671,544;167847
Perinci/Sub/Util.pm,3598937,9870,545;168287
Perinci/Sub/Util/ResObj.pm,3608842,243,546;168639
Perinci/Sub/Util/Sort.pm,3609118,463,547;168654
Perinci/Sub/Wrapper.pm,3609612,44311,548;168683
Proc/PID/File.pm,3653948,3636,549;170005
Progress/Any.pm,3657608,13409,550;170192
Progress/Any/Output.pm,3671048,1286,551;170704
Progress/Any/Output/Null.pm,3672370,226,552;170768
Progress/Any/Output/TermProgressBarColor.pm,3672648,5115,553;170789
Regexp/Stringify.pm,3677791,2481,554;170983
Rinci.pm,3680289,64,555;171083
Role/Tiny.pm,3680374,11133,556;171091
Role/Tiny/With.pm,3691533,297,557;171498
Sah/Schema/Rinci.pm,3691858,4218,558;171520
Scalar/Util/Numeric/PP.pm,3696110,1337,559;171701
String/Elide/Parts.pm,3697477,3763,560;171771
String/Indent.pm,3701265,616,561;171904
String/LineNumber.pm,3701910,859,562;171936
String/PerlQuote.pm,3702797,890,563;171976
String/ShellQuote.pm,3703716,1822,564;172026
String/Trim/More.pm,3705566,1446,565;172140
String/Wildcard/Bash.pm,3707044,2159,566;172225
Sub/Defer.pm,3709224,1854,567;172313
Sub/Delete.pm,3711100,1622,568;172393
Sub/Exporter/Progressive.pm,3712758,2888,569;172459
Sub/Install.pm,3715669,4012,570;172553
Sub/Quote.pm,3719702,4516,571;172724
Sys/Syslog.pm,3724240,19395,572;172896
Term/ANSIColor.pm,3743661,8955,573;173681
Term/App/Role/Attrs.pm,3752647,6604,574;174021
Term/App/Roles.pm,3759277,101,575;174246
Term/Detect/Software.pm,3759410,6916,576;174255
Test/Config/IOD/Common.pm,3766360,6051,577;174456
Test/Data/Sah.pm,3772436,2307,578;174726
Test/Perinci/Sub/Wrapper.pm,3774779,8753,579;174796
Text/ANSI/BaseUtil.pm,3783562,21706,580;175014
Text/ANSI/NonWideUtil.pm,3805301,910,581;175743
Text/ANSI/Util.pm,3806237,1271,582;175780
Text/ANSITable.pm,3807534,47404,583;175831
Text/ANSITable/BorderStyle/Default.pm,3854984,10020,584;177383
Text/ANSITable/ColorTheme/Default.pm,3865049,3078,585;177795
Text/ANSITable/StyleSet/AltRow.pm,3868169,1103,586;177901
Text/Table/Tiny.pm,3869299,2508,587;177947
Text/sprintfn.pm,3871832,3295,588;178038
Tie/Cache.pm,3875148,9555,589;178163
Tie/IxHash.pm,3884725,6075,590;178605
Time/Duration.pm,3890825,5577,591;178951
Try/Tiny.pm,3896422,2881,592;179155
URI.pm,3899318,6630,593;179300
URI/Escape.pm,3905970,1725,594;179624
URI/Find.pm,3907715,6868,595;179702
URI/Find/Schemeless.pm,3914614,11664,596;179996
URI/Heuristic.pm,3926303,3511,597;180726
URI/IRI.pm,3929833,704,598;180882
URI/QueryParam.pm,3930563,1901,599;180926
URI/Split.pm,3932485,1040,600;181016
URI/URL.pm,3933544,3546,601;181061
URI/WithBase.pm,3937114,2154,602;181239
URI/_foreign.pm,3939292,117,603;181349
URI/_generic.pm,3939433,5373,604;181359
URI/_idna.pm,3944827,1796,605;181604
URI/_ldap.pm,3946644,2784,606;181686
URI/_login.pm,3949450,133,607;181816
URI/_punycode.pm,3949608,3608,608;181827
URI/_query.pm,3953238,2401,609;181975
URI/_segment.pm,3955663,357,610;182067
URI/_server.pm,3956043,3710,611;182089
URI/_userpass.pm,3959778,1089,612;182255
URI/data.pm,3960887,1642,613;182310
URI/file.pm,3962549,2852,614;182387
URI/file/Base.pm,3965426,1552,615;182514
URI/file/FAT.pm,3967002,406,616;182598
URI/file/Mac.pm,3967432,2157,617;182624
URI/file/OS2.pm,3969613,470,618;182741
URI/file/QNX.pm,3970107,303,619;182771
URI/file/Unix.pm,3970435,954,620;182790
URI/file/Win32.pm,3971415,1680,621;182846
URI/ftp.pm,3973114,663,622;182931
URI/gopher.pm,3973799,1581,623;182969
URI/http.pm,3975400,452,624;183044
URI/https.pm,3975873,158,625;183071
URI/ldap.pm,3976051,263,626;183085
URI/ldapi.pm,3976335,470,627;183106
URI/ldaps.pm,3976826,158,628;183135
URI/mailto.pm,3977006,1164,629;183149
URI/mms.pm,3978189,137,630;183218
URI/news.pm,3978346,1200,631;183230
URI/nntp.pm,3979566,111,632;183296
URI/pop.pm,3979696,1227,633;183306
URI/rlogin.pm,3980945,141,634;183376
URI/rsync.pm,3981107,162,635;183388
URI/rtsp.pm,3981289,137,636;183401
URI/rtspu.pm,3981447,138,637;183413
URI/sftp.pm,3981605,108,638;183425
URI/sip.pm,3981732,1547,639;183435
URI/sips.pm,3983299,157,640;183513
URI/snews.pm,3983477,160,641;183527
URI/ssh.pm,3983656,159,642;183541
URI/telnet.pm,3983837,140,643;183556
URI/tn3270.pm,3983999,140,644;183568
URI/urn.pm,3984158,1931,645;183580
URI/urn/isbn.pm,3986113,2158,646;183677
URI/urn/oid.pm,3988294,293,647;183776
UUID/Random.pm,3988610,382,648;183796
Version/Util.pm,3989016,1318,649;183819
YAML.pm,3990350,2382,650;183887
YAML/Any.pm,3992752,2772,651;183983
YAML/Dumper.pm,3995547,15047,652;184105
YAML/Dumper/Base.pm,4010622,3495,653;184626
YAML/Error.pm,4014139,5882,654;184732
YAML/Loader.pm,4020044,21564,655;184921
YAML/Loader/Base.pm,4041636,1015,656;185619
YAML/Marshall.pm,4042676,914,657;185652
YAML/Mo.pm,4043609,2690,658;185699
YAML/Node.pm,4046320,4359,659;185770
YAML/Tag.pm,4050699,235,660;185985
YAML/Types.pm,4050956,5770,661;186004
experimental.pm,4056750,2681,662;186227
namespace/clean.pm,4059458,4664,663;186337
oo.pm,4064136,591,664;186526

### Algorithm/Dependency.pm ###
 package Algorithm::Dependency;
 
 
 use 5.005;
 use strict;
 use Algorithm::Dependency::Item   ();
 use Algorithm::Dependency::Source ();
 use Params::Util qw{_INSTANCE _ARRAY};
 
 use vars qw{$VERSION};
 BEGIN {
 	$VERSION = '1.110';
 }
 
 
 
 
 
 
 
 sub new {
 	my $class  = shift;
 	my %args   = @_;
 	my $source = _INSTANCE($args{source}, 'Algorithm::Dependency::Source')
 		or return undef;
 
 	my $self = bless {
 		source   => $source, 
 		selected => {},
 		}, $class;
 
 	if ( $args{ignore_orphans} ) {
 		$self->{ignore_orphans} = 1;
 	}
 
 	_ARRAY($args{selected}) or return $self;
 
 	my %selected = ();
 	foreach my $id ( @{ $args{selected} } ) {
 		return undef unless $source->item($id);
 
 		return undef if $selected{$id};
 
 		$selected{$id} = 1;
 	}
 
 	$self->{selected} = \%selected;
 	$self;
 }
 
 
 
 
 
 
 
 sub source { $_[0]->{source} }
 
 
 sub selected_list { sort keys %{$_[0]->{selected}} }
 
 
 sub selected { $_[0]->{selected}->{$_[1]} }
 
 
 sub item { $_[0]->{source}->item($_[1]) }
 
 
 
 
 
 
 
 sub depends {
 	my $self    = shift;
 	my @stack   = @_ or return undef;
 	my @depends = ();
 	my %checked = ();
 
 	while ( my $id = shift @stack ) {
 		my $Item = $self->{source}->item($id)
 		or $self->{ignore_orphans} ? next : return undef;
 
 		next if $checked{$id};
 
 		push @stack, $Item->depends;
 		$checked{$id} = 1;
 
 		unless ( scalar grep { $id eq $_ } @_ ) {
 			push @depends, $id;
 		}
 	}
 
 	my $s = $self->{selected};
 	return [ sort grep { ! $s->{$_} } @depends ];
 }
 
 
 sub schedule {
 	my $self  = shift;
 	my @items = @_ or return undef;
 
 	my $depends = $self->depends( @items ) or return undef;
 
 	my $s = $self->{selected};
 	return [ sort grep { ! $s->{$_} } @items, @$depends ];
 }
 
 
 sub schedule_all {
 	my $self = shift;
 	$self->schedule( map { $_->id } $self->source->items );
 }
 
 1;
 
### Algorithm/Dependency/Item.pm ###
 package Algorithm::Dependency::Item;
 
 
 use 5.005;
 use strict;
 use Algorithm::Dependency ();
 
 use vars qw{$VERSION};
 BEGIN {
 	$VERSION = '1.110';
 }
 
 
 
 
 
 
 
 sub new {
 	my $class = shift;
 	my $id    = (defined $_[0] and ! ref $_[0] and $_[0] ne '') ? shift : return undef;
 	bless { id => $id, depends => [ @_ ] }, $class;
 }
 
 
 sub id { $_[0]->{id} }
 
 
 sub depends { @{$_[0]->{depends}} }
 
 1;
 
### Algorithm/Dependency/Ordered.pm ###
 package Algorithm::Dependency::Ordered;
 
 
 use 5.005;
 use strict;
 use Algorithm::Dependency ();
 
 use vars qw{$VERSION @ISA};
 BEGIN {
 	$VERSION = '1.110';
 	@ISA     = 'Algorithm::Dependency';
 }
 
 
 
 
 
 sub schedule {
 	my $self   = shift;
 	my $source = $self->{source};
 	my @items  = @_ or return undef;
 	return undef if grep { ! $source->item($_) } @items;
 
 	my $rv    = $self->SUPER::schedule( @items );
 	my @queue = $rv ? @$rv : return undef;
 
 	my %selected = %{ $self->{selected} };
 
 	my $error_marker = '';
 
 	my @schedule = ();
 	while ( my $id = shift @queue ) {
 		return undef if $id eq $error_marker;
 
 		my $Item    = $self->{source}->item($id) or return undef;
 		my @missing = grep { ! $selected{$_} } $Item->depends;
 
 		if ( $self->{ignore_orphans} ) {
 			@missing = grep { $self->{source}->item($_) } @missing;
 		}
 
 		if ( @missing ) {
 			$error_marker = $id unless $error_marker;
 
 			push @queue, $id;
 			next;
 		}
 
 		push @schedule, $id;
 		$selected{$id} = 1;
 		$error_marker  = '';
 	}
 
 	\@schedule;
 }
 
 1;
 
### Algorithm/Dependency/Source.pm ###
 package Algorithm::Dependency::Source;
 
 
 use 5.005;
 use strict;
 use Algorithm::Dependency ();
 use Params::Util qw{_SET};
 
 use vars qw{$VERSION};
 BEGIN {
 	$VERSION = '1.110';
 }
 
 
 
 
 
 
 
 sub new {
 	my $class = shift;
 
 	if ( $class eq __PACKAGE__ ) {
 		die "Cannot directly instantiate Algorithm::Dependency::Source."
 			. " You must use a subclass";
 	}
 
 	my $self = bless {
 		loaded      => 0,
 
 		items_hash  => undef,
 		items_array => undef,
 		}, $class;
 
 	$self;
 }
 
 
 sub load {
 	my $self = shift;
 
 	if ( $self->{loaded} ) {
 		$self->{loaded}      = 0;
 		$self->{items_hash}  = undef;
 		$self->{items_array} = undef;
 	}
 
 	my $items = $self->_load_item_list;
 	return $items unless $items;
 	unless ( _SET($items, 'Algorithm::Dependency::Item') ) {
 		die( ref($self) . "::_load_item_list did not return an Algorithm::Dependency::Item set" );
 	}
 
 	foreach my $item ( @$items ) {
 		my $id = $item->id;
 		if ( $self->{items_hash}->{ $id } ) {
 			return undef;
 		}
 
 		push @{ $self->{items_array} }, $item;
 		$self->{items_hash}->{$id} = $item;
 	}
 
 	$self->{loaded} = 1;
 }
 
 
 sub item {
 	my $self = shift;
 	my $id   = (defined $_[0] and ! ref $_[0] and $_[0] ne '') ? shift : return undef;
 	$self->{loaded} or $self->load or return undef;
 
 	$self->{items_hash}->{$id};
 }
 
 
 sub items {
 	my $self = shift;
 	$self->{loaded} or $self->load or return undef;
 	@{ $self->{items_array} };
 }
 
 
 sub missing_dependencies {
 	my $self = shift;
 	$self->{loaded} or $self->load or return undef;
 	
 	my %missing = map  { $_ => 1           }
 	              grep { ! $self->item($_) }
 	              map  { $_->depends       }
 	              $self->items;
 	%missing ? [ sort keys %missing ] : 0;
 }
 
 
 
 
 
 
 sub _load_item_list {
 	die "Class $_[0] failed to define the method _load_item_list";
 }
 
 1;
 
### Algorithm/Dependency/Source/File.pm ###
 package Algorithm::Dependency::Source::File;
 
 
 use 5.005;
 use strict;
 use Algorithm::Dependency::Source ();
 
 use vars qw{$VERSION @ISA};
 BEGIN {
 	$VERSION = '1.110';
 	@ISA     = 'Algorithm::Dependency::Source';
 }
 
 
 
 
 
 
 
 sub new {
 	my $class    = shift;
 	my $filename = shift or return undef;
 	return undef unless -r $filename;
 
 	my $self = $class->SUPER::new() or return undef;
 
 	$self->{filename} = $filename;
 
 	$self;
 }
 
 
 
 
 
 
 sub _load_item_list {
 	my $self = shift;
 
 	local $/ = undef;
 	open( FILE, $self->{filename} ) or return undef;
 	defined(my $source = <FILE>)    or return undef;
 	close( FILE )                   or return undef;
 
 	my @content = grep { ! /^\s*(?:\#|$)/ } 
 		split /\s*[\015\012][\s\015\012]*/, $source;
 
 	my @Items = ();
 	foreach my $line ( @content ) {
 		my @sections = grep { length $_ } split /\W+/, $line;
 		return undef unless scalar @sections;
 
 		my $Item = Algorithm::Dependency::Item->new( @sections ) or return undef;
 		push @Items, $Item;
 	}
 
 	\@Items;
 }
 
 1;
 
### Algorithm/Dependency/Source/HoA.pm ###
 package Algorithm::Dependency::Source::HoA;
 
 
 use 5.005;
 use strict;
 use Algorithm::Dependency::Source ();
 use Params::Util qw{_HASH _ARRAY0};
 
 use vars qw{$VERSION @ISA};
 BEGIN {
 	$VERSION = '1.110';
 	@ISA     = 'Algorithm::Dependency::Source';
 }
 
 
 
 
 
 
 
 sub new {
 	my $class = shift;
 	my $hash  = _HASH(shift) or return undef;
 	foreach my $deps ( values %$hash ) {
 		_ARRAY0($deps) or return undef;
 	}
 
 	my $self = $class->SUPER::new() or return undef;
 
 	$self->{hash} = $hash;
 
 	$self;
 }
 
 
 
 
 
 
 sub _load_item_list {
 	my $self = shift;
 
 	my $hash  = $self->{hash};
 	my @items = map {
 		Algorithm::Dependency::Item->new( $_, @{$hash->{$_}} )
 		or return undef;
 		} keys %$hash;
 
 	\@items;
 }
 
 1;
 
### Algorithm/Dependency/Source/Invert.pm ###
 package Algorithm::Dependency::Source::Invert;
 
 
 use 5.005;
 use strict;
 use Params::Util '_INSTANCE';
 use Algorithm::Dependency::Source::HoA ();
 
 use vars qw{$VERSION @ISA};
 BEGIN {
 	$VERSION = '1.110';
 	@ISA     = 'Algorithm::Dependency::Source::HoA';
 }
 
 
 
 
 
 
 sub new {
 	my $class  = shift;
 	my $source = _INSTANCE(shift, 'Algorithm::Dependency::Source') or return undef;
 
 	my @items = $source->items;
 	my %hoa   = map { $_->id => [ ] } @items;
 	foreach my $item ( @items ) {
 		my $id   = $item->id;
 		my @deps = $item->depends;
 		foreach my $dep ( @deps ) {
 			push @{ $hoa{$dep} }, $id;
 		}
 	}
 
 	$class->SUPER::new( \%hoa );
 }
 
 1;
 
### Algorithm/Dependency/Weight.pm ###
 package Algorithm::Dependency::Weight;
 
 
 use 5.005;
 use strict;
 use List::Util            ();
 use Algorithm::Dependency ();
 use Params::Util qw{_INSTANCE _STRING};
 
 use vars qw{$VERSION};
 BEGIN {
 	$VERSION = '1.110';
 }
 
 
 
 
 
 
 
 sub new {
 	my $class = shift;
 	my %args  = @_;
 
 	my $source = _INSTANCE($args{source}, 'Algorithm::Dependency')
 		? $args{source}->source
 		: _INSTANCE($args{source}, 'Algorithm::Dependency::Source')
 		or return undef;
 
 	my $algdep = Algorithm::Dependency->new(
 		source         => $source,
 		ignore_orphans => 1,
 		) or return undef;
 
 	my $self = bless {
 		source => $source,
 		algdep => $algdep,
 		weight => {},
 		}, $class;
 
 	$self;
 }
 
 
 sub source {
 	$_[0]->{source}
 }
 
 
 
 
 
 
 
 sub weight {
 	my $self = shift;
 	my $id   = defined(_STRING($_[0])) ? shift : return undef;
 	$self->{weight}->{$id} or
 	$self->{weight}->{$id} = $self->_weight($id);
 }
 
 sub _weight {
 	my $self  = shift;
 	my $items = $self->{algdep}->schedule($_[0]) or return undef;
 	scalar(@$items);
 }
 
 
 sub weight_merged {
 	my $self  = shift;
 	my $items = $self->{algdep}->schedule(@_) or return undef;
 	scalar(@$items);
 }
 
 
 sub weight_hash {
 	my $self  = shift;
 	my @names = @_;
 
 	my %hash = ();
 	foreach my $name ( @names ) {
 		if ( $self->{weight}->{$name} ) {
 			$hash{$name} = $self->{weight}->{$name};
 			next;
 		}
 		$hash{$name} = $self->weight($name) or return undef;
 	}
 
 	\%hash;
 }
 
 
 sub weight_all {
 	my $self  = shift;
 	my @items = $self->source->items;
 	defined $items[0] or return undef;
 	$self->weight_hash( map { $_->id } @items );
 }
 
 1;
 
### B/Hooks/EndOfScope.pm ###
 package B::Hooks::EndOfScope; 
 
 use strict;
 use warnings;
 
 our $VERSION = '0.15';
 
 use 5.008001;
 
 BEGIN {
   use Module::Implementation 0.05;
   Module::Implementation::build_loader_sub(
     implementations => [ 'XS', 'PP' ],
     symbols => [ 'on_scope_end' ],
   )->();
 }
 
 use Sub::Exporter::Progressive 0.001006 -setup => {
   exports => [ 'on_scope_end' ],
   groups  => { default => ['on_scope_end'] },
 };
 
 
 1;
 
 __END__
 
### B/Hooks/EndOfScope/PP.pm ###
 package B::Hooks::EndOfScope::PP;
 
 use warnings;
 use strict;
 
 our $VERSION = '0.15';
 
 use constant _PERL_VERSION => "$]";
 
 BEGIN {
   if (_PERL_VERSION =~ /^5\.009/) {
     die "By design B::Hooks::EndOfScope does not operate in pure-perl mode on perl 5.9.X\n"
   }
   elsif (_PERL_VERSION < '5.010') {
     require B::Hooks::EndOfScope::PP::HintHash;
     *on_scope_end = \&B::Hooks::EndOfScope::PP::HintHash::on_scope_end;
   }
   else {
     require B::Hooks::EndOfScope::PP::FieldHash;
     *on_scope_end = \&B::Hooks::EndOfScope::PP::FieldHash::on_scope_end;
   }
 }
 
 use Sub::Exporter::Progressive 0.001006 -setup => {
   exports => ['on_scope_end'],
   groups  => { default => ['on_scope_end'] },
 };
 
 sub __invoke_callback {
   local $@;
   eval { $_[0]->(); 1 } or do {
     my $err = $@;
     require Carp;
     Carp::cluck( (join ' ',
       'A scope-end callback raised an exception, which can not be propagated when',
       'B::Hooks::EndOfScope operates in pure-perl mode. Your program will CONTINUE',
       'EXECUTION AS IF NOTHING HAPPENED AFTER THIS WARNING. Below is the complete',
       'exception text, followed by a stack-trace of the callback execution:',
     ) . "\n\n$err\n\r" );
 
     sleep 1 if -t *STDERR;  
   };
 }
 
 
 1;
 
 __END__
 
### B/Hooks/EndOfScope/XS.pm ###
 package B::Hooks::EndOfScope::XS;
 
 use strict;
 use warnings;
 
 our $VERSION = '0.15';
 
 use Variable::Magic 0.48 ();
 use Sub::Exporter::Progressive 0.001006 -setup => {
   exports => ['on_scope_end'],
   groups  => { default => ['on_scope_end'] },
 };
 
 my $wiz = Variable::Magic::wizard
   data => sub { [$_[1]] },
   free => sub { $_->() for @{ $_[1] }; () },
   local => \undef
 ;
 
 sub on_scope_end (&) {
   my $cb = shift;
 
   $^H |= 0x020000;
 
   if (my $stack = Variable::Magic::getdata %^H, $wiz) {
     push @{ $stack }, $cb;
   }
   else {
     Variable::Magic::cast %^H, $wiz, $cb;
   }
 }
 
 
 
 1;
 
 __END__
 
### Border/Style.pm ###
 package Border::Style;
 
 our $DATE = '2014-12-10'; 
 our $VERSION = '0.01'; 
 
 1;
 
 __END__
 
### Border/Style/Role.pm ###
 package Border::Style::Role;
 
 our $DATE = '2014-12-10'; 
 our $VERSION = '0.01'; 
 
 
 use 5.010001;
 use Moo::Role;
 
 with 'Term::App::Role::Attrs';
 
 has border_style_args  => (is => 'rw', default => sub { {} });
 has _all_border_styles => (is => 'rw');
 
 sub get_border_char {
     my ($self, $y, $x, $n, $args) = @_;
     my $bch = $self->{border_style}{chars};
     $n //= 1;
     if (ref($bch) eq 'CODE') {
         $bch->($self, y=>$y, x=>$x, n=>$n, %{$args // {}});
     } else {
         $bch->[$y][$x] x $n;
     }
 }
 
 sub border_style {
     my $self = shift;
 
     if (!@_) { return $self->{border_style} }
     my $bs = shift;
 
     my $p2 = "";
     if (!ref($bs)) {
         $p2 = " named $bs";
         $bs = $self->get_border_style($bs);
     }
 
     my $err;
     if ($bs->{box_chars} && !$self->use_box_chars) {
         $err = "use_box_chars is set to false";
     } elsif ($bs->{utf8} && !$self->use_utf8) {
         $err = "use_utf8 is set to false";
     }
     die "Can't select border style$p2: $err" if $err;
 
     $self->{border_style} = $bs;
 }
 
 sub get_border_style {
     my ($self, $bs) = @_;
 
     my $prefix = (ref($self) ? ref($self) : $self ) .
         '::BorderStyle'; 
 
     my $bss;
     my $pkg;
     if ($bs =~ s/(.+):://) {
         $pkg = "$prefix\::$1";
         my $pkgp = $pkg; $pkgp =~ s!::!/!g;
         require "$pkgp.pm";
         no strict 'refs';
         $bss = \%{"$pkg\::border_styles"};
     } else {
         die "Please use SubPackage::name to choose border style, ".
             "use list_border_styles() to list available styles";
     }
     $bss->{$bs} or die "Unknown border style name '$bs'".
         ($pkg ? " in package $prefix\::$pkg" : "");
     $bss->{$bs};
 }
 
 sub list_border_styles {
     require Module::List;
     require Module::Load;
 
     my ($self, $detail) = @_;
 
     my $prefix = (ref($self) ? ref($self) : $self ) .
         '::BorderStyle'; 
     my $all_bs = $self->_all_border_styles;
 
     if (!$all_bs) {
         my $mods = Module::List::list_modules("$prefix\::",
                                               {list_modules=>1, recurse=>1});
         no strict 'refs';
         $all_bs = {};
         for my $mod (sort keys %$mods) {
             Module::Load::load($mod);
             my $bs = \%{"$mod\::border_styles"};
             for (keys %$bs) {
                 my $cutmod = $mod;
                 $cutmod =~ s/^\Q$prefix\E:://;
                 my $name = "$cutmod\::$_";
                 $bs->{$_}{name} = $name;
                 $all_bs->{$name} = $bs->{$_};
             }
         }
         $self->_all_border_styles($all_bs);
     }
 
     if ($detail) {
         return $all_bs;
     } else {
         return sort keys %$all_bs;
     }
 }
 
 1;
 
 __END__
 
### Class/Inspector.pm ###
 package Class::Inspector;
 
 
 use 5.006;
 use strict qw{vars subs};
 use warnings;
 use File::Spec ();
 
 use vars qw{$VERSION $RE_IDENTIFIER $RE_CLASS $UNIX};
 BEGIN {
 	$VERSION = '1.28';
 
 	SCOPE: {
 		local $@;
 		eval "require utf8; utf8->import";
 	}
 
 	$RE_IDENTIFIER = qr/\A[^\W\d]\w*\z/s;
 	$RE_CLASS      = qr/\A[^\W\d]\w*(?:(?:\'|::)\w+)*\z/s;
 
 	$UNIX  = !! ( $File::Spec::ISA[0] eq 'File::Spec::Unix'  );
 }
 
 
 
 
 
 
 
 sub installed {
 	my $class = shift;
 	!! ($class->loaded_filename($_[0]) or $class->resolved_filename($_[0]));
 }
 
 
 sub loaded {
 	my $class = shift;
 	my $name  = $class->_class(shift) or return undef;
 	$class->_loaded($name);
 }
 
 sub _loaded {
 	my $class = shift;
 	my $name  = shift;
 
 	return 1 if defined ${"${name}::VERSION"};
 	return 1 if @{"${name}::ISA"};
 
 	foreach ( keys %{"${name}::"} ) {
 		next if substr($_, -2, 2) eq '::';
 		return 1 if defined &{"${name}::$_"};
 	}
 
 	my $filename = $class->_inc_filename($name);
 	return 1 if defined $INC{$filename};
 
 	'';
 }
 
 
 sub filename {
 	my $class = shift;
 	my $name  = $class->_class(shift) or return undef;
 	File::Spec->catfile( split /(?:\'|::)/, $name ) . '.pm';
 }
 
 
 sub resolved_filename {
 	my $class     = shift;
 	my $filename  = $class->_inc_filename(shift) or return undef;
 	my @try_first = @_;
 
 	foreach ( @try_first, @INC ) {
 		my $full = "$_/$filename";
 		next unless -e $full;
 		return $UNIX ? $full : $class->_inc_to_local($full);
 	}
 
 	'';
 }
 
 
 sub loaded_filename {
 	my $class    = shift;
 	my $filename = $class->_inc_filename(shift);
 	$UNIX ? $INC{$filename} : $class->_inc_to_local($INC{$filename});
 }
 
 
 
 
 
 
 
 sub functions {
 	my $class = shift;
 	my $name  = $class->_class(shift) or return undef;
 	return undef unless $class->loaded( $name );
 
 	my @functions = sort grep { /$RE_IDENTIFIER/o }
 		grep { defined &{"${name}::$_"} }
 		keys %{"${name}::"};
 	\@functions;
 }
 
 
 sub function_refs {
 	my $class = shift;
 	my $name  = $class->_class(shift) or return undef;
 	return undef unless $class->loaded( $name );
 
 	my @functions = map { \&{"${name}::$_"} }
 		sort grep { /$RE_IDENTIFIER/o }
 		grep { defined &{"${name}::$_"} }
 		keys %{"${name}::"};
 	\@functions;
 }
 
 
 sub function_exists {
 	my $class    = shift;
 	my $name     = $class->_class( shift ) or return undef;
 	my $function = shift or return undef;
 
 	return undef unless $class->loaded( $name );
 
 	defined &{"${name}::$function"};
 }
 
 
 sub methods {
 	my $class     = shift;
 	my $name      = $class->_class( shift ) or return undef;
 	my @arguments = map { lc $_ } @_;
 
 	my %options = ();
 	foreach ( @arguments ) {
 		if ( $_ eq 'public' ) {
 			return undef if $options{private};
 			$options{public} = 1;
 
 		} elsif ( $_ eq 'private' ) {
 			return undef if $options{public};
 			$options{private} = 1;
 
 		} elsif ( $_ eq 'full' ) {
 			return undef if $options{expanded};
 			$options{full} = 1;
 
 		} elsif ( $_ eq 'expanded' ) {
 			return undef if $options{full};
 			$options{expanded} = 1;
 
 		} else {
 			return undef;
 		}
 	}
 
 	return undef unless $class->loaded( $name );
 
 	my @path  = ();
 	my @queue = ( $name );
 	my %seen  = ( $name => 1 );
 	while ( my $cl = shift @queue ) {
 		push @path, $cl;
 		unshift @queue, grep { ! $seen{$_}++ }
 			map { s/^::/main::/; s/\'/::/g; $_ }
 			( @{"${cl}::ISA"} );
 	}
 
 	my %methods = ();
 	foreach my $namespace ( @path ) {
 		my @functions = grep { ! $methods{$_} }
 			grep { /$RE_IDENTIFIER/o }
 			grep { defined &{"${namespace}::$_"} } 
 			keys %{"${namespace}::"};
 		foreach ( @functions ) {
 			$methods{$_} = $namespace;
 		}
 	}
 
 	my @methodlist = sort keys %methods;
 	@methodlist = grep { ! /^\_/ } @methodlist if $options{public};
 	@methodlist = grep {   /^\_/ } @methodlist if $options{private};
 
 	@methodlist = map { "$methods{$_}::$_" } @methodlist if $options{full};
 	@methodlist = map { 
 		[ "$methods{$_}::$_", $methods{$_}, $_, \&{"$methods{$_}::$_"} ] 
 		} @methodlist if $options{expanded};
 
 	\@methodlist;
 }
 
 
 
 
 
 
 
 sub subclasses {
 	my $class = shift;
 	my $name  = $class->_class( shift ) or return undef;
 
 	my @found = ();
 	my @queue = grep { $_ ne 'main' } $class->_subnames('');
 	while ( @queue ) {
 		my $c = shift(@queue); 
 		if ( $class->_loaded($c) ) {
 			local $@;
 			eval {
 				if ( $c->isa($name) ) {
 					push @found, $c unless $c eq $name;
 				}
 			};
 		}
 
 		unshift @queue, map { "${c}::$_" } $class->_subnames($c);
 	}
 
 	@found ? \@found : '';
 }
 
 sub _subnames {
 	my ($class, $name) = @_;
 	return sort
 		grep {
 			substr($_, -2, 2, '') eq '::'
 			and
 			/$RE_IDENTIFIER/o
 		}
 		keys %{"${name}::"};
 }
 
 
 
 
 
 
 
 sub children {
 	my $class = shift;
 	my $name  = $class->_class(shift) or return ();
 
 	no strict 'refs';
 	map { "${name}::$_" } sort grep { s/::$// } keys %{"${name}::"};
 }
 
 sub recursive_children {
 	my $class    = shift;
 	my $name     = $class->_class(shift) or return ();
 	my @children = ( $name );
 
 	my $i = 0;
 	no strict 'refs';
 	while ( my $namespace = $children[$i++] ) {
 		push @children, map { "${namespace}::$_" }
 			grep { ! /^::/ } 
 			grep { s/::$// }
 			keys %{"${namespace}::"};
 	}
 
 	sort @children;
 }
 
 
 
 
 
 
 sub _class {
 	my $class = shift;
 	my $name  = shift or return '';
 
 	return 'main' if $name eq '::';
 	$name =~ s/\A::/main::/;
 
 	$name =~ /$RE_CLASS/o ? $name : '';
 }
 
 sub _inc_filename {
 	my $class = shift;
 	my $name  = $class->_class(shift) or return undef;
 	join( '/', split /(?:\'|::)/, $name ) . '.pm';
 }
 
 sub _inc_to_local {
 	return $_[1] if $UNIX;
 
 	my $class              = shift;
 	my $inc_name           = shift or return undef;
 	my ($vol, $dir, $file) = File::Spec->splitpath( $inc_name );
 	$dir = File::Spec->catdir( File::Spec->splitdir( $dir || "" ) );
 	File::Spec->catpath( $vol, $dir, $file || "" );
 }
 
 1;
 
### Class/Inspector/Functions.pm ###
 package Class::Inspector::Functions;
 
 use 5.006;
 use strict;
 use warnings;
 use Exporter         ();
 use Class::Inspector ();
 
 use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS $VERSION);
 BEGIN {
 	$VERSION = '1.28';
 	@ISA     = 'Exporter';
 
 
 	@EXPORT = qw(
 		installed
 		loaded
 
 		filename
 		functions
 		methods
 
 		subclasses
 	);
 
 	@EXPORT_OK = qw(
 		resolved_filename
 		loaded_filename
 
 		function_refs
 		function_exists
 	);
 
 	%EXPORT_TAGS = ( ALL => [ @EXPORT_OK, @EXPORT ] );
 
 	foreach my $meth (@EXPORT, @EXPORT_OK) {
 	    my $sub = Class::Inspector->can($meth);
 	    no strict 'refs';
 	    *{$meth} = sub {&$sub('Class::Inspector', @_)};
 	}
 
 }
 
 1;
 
 __END__
 
### Class/Method/Modifiers.pm ###
 use strict;
 use warnings;
 package Class::Method::Modifiers;
 BEGIN {
   $Class::Method::Modifiers::AUTHORITY = 'cpan:SARTAK';
 }
 $Class::Method::Modifiers::VERSION = '2.11';
 
 use base 'Exporter';
 
 our @EXPORT = qw(before after around);
 our @EXPORT_OK = (@EXPORT, qw(fresh install_modifier));
 our %EXPORT_TAGS = (
     moose => [qw(before after around)],
     all   => \@EXPORT_OK,
 );
 
 BEGIN {
   *_HAS_READONLY = $] >= 5.008 ? sub(){1} : sub(){0};
 }
 
 our %MODIFIER_CACHE;
 
 sub _install_modifier; 
 *_install_modifier = \&install_modifier;
 
 sub install_modifier {
     my $into  = shift;
     my $type  = shift;
     my $code  = pop;
     my @names = @_;
 
     @names = @{ $names[0] } if ref($names[0]) eq 'ARRAY';
 
     return _fresh($into, $code, @names) if $type eq 'fresh';
 
     for my $name (@names) {
         my $hit = $into->can($name) or do {
             require Carp;
             Carp::confess("The method '$name' is not found in the inheritance hierarchy for class $into");
         };
 
         my $qualified = $into.'::'.$name;
         my $cache = $MODIFIER_CACHE{$into}{$name} ||= {
             before => [],
             after  => [],
             around => [],
         };
 
         if (!exists($cache->{"orig"})) {
             no strict 'refs';
 
             $cache->{"orig"} = *{$qualified}{CODE};
 
             $cache->{"wrapped"} = $cache->{"orig"} || $hit; 
         }
 
         if ($type eq 'after') {
             push @{ $cache->{$type} }, $code;
         }
         else {
             unshift @{ $cache->{$type} }, $code;
         }
 
         if ($type eq 'around') {
             my $method = $cache->{wrapped};
             my $attrs = _sub_attrs($code);
             $cache->{wrapped} = eval "package $into; +sub $attrs { \$code->(\$method, \@_); };";
         }
 
         if (@{ $cache->{$type} } == 1) {
 
             my $before  = $cache->{"before"};
             my $after   = $cache->{"after"};
 
             my $wrapped = \$cache->{"wrapped"};
 
             my $attrs = _sub_attrs($cache->{wrapped});
 
             my $generated = "package $into;\n";
             $generated .= "sub $name $attrs {";
 
             if (@$before) {
                 $generated .= '
                     for my $method (@$before) {
                         $method->(@_);
                     }
                 ';
             }
 
             if (@$after) {
                 $generated .= '
                     my $ret;
                     if (wantarray) {
                         $ret = [$$wrapped->(@_)];
                         '.(_HAS_READONLY ? 'Internals::SvREADONLY(@$ret, 1);' : '').'
                     }
                     elsif (defined wantarray) {
                         $ret = \($$wrapped->(@_));
                     }
                     else {
                         $$wrapped->(@_);
                     }
 
                     for my $method (@$after) {
                         $method->(@_);
                     }
 
                     wantarray ? @$ret : $ret ? $$ret : ();
                 '
             }
             else {
                 $generated .= '$$wrapped->(@_);';
             }
 
             $generated .= '}';
 
             no strict 'refs';
             no warnings 'redefine';
             no warnings 'closure';
             eval $generated;
         };
     }
 }
 
 sub before {
     _install_modifier(scalar(caller), 'before', @_);
 }
 
 sub after {
     _install_modifier(scalar(caller), 'after', @_);
 }
 
 sub around {
     _install_modifier(scalar(caller), 'around', @_);
 }
 
 sub fresh {
     my $code = pop;
     my @names = @_;
 
     @names = @{ $names[0] } if ref($names[0]) eq 'ARRAY';
 
     _fresh(scalar(caller), $code, @names);
 }
 
 sub _fresh {
     my ($into, $code, @names) = @_;
 
     for my $name (@names) {
         if ($name !~ /\A [a-zA-Z_] [a-zA-Z0-9_]* \z/xms) {
             require Carp;
             Carp::confess("Invalid method name '$name'");
         }
         if ($into->can($name)) {
             require Carp;
             Carp::confess("Class $into already has a method named '$name'");
         }
 
         if (_is_in_package($code, $into)) {
             no strict 'refs';
             *{"$into\::$name"} = $code;
         }
         else {
             no warnings 'closure'; 
             my $attrs = _sub_attrs($code);
             eval "package $into; sub $name $attrs { \$code->(\@_) }";
         }
     }
 }
 
 sub _sub_attrs {
     my ($coderef) = @_;
     local *_sub = $coderef;
     local $@;
     (eval 'sub { _sub = 1 }') ? ':lvalue' : '';
 }
 
 sub _is_in_package {
     my ($coderef, $package) = @_;
     require B;
     my $cv = B::svref_2object($coderef);
     return $cv->GV->STASH->NAME eq $package;
 }
 
 1;
 
 __END__
 
### Clone/PP.pm ###
 package Clone::PP;
 
 use 5.006;
 use strict;
 use warnings;
 use vars qw($VERSION @EXPORT_OK);
 use Exporter;
 
 $VERSION = 1.06;
 
 @EXPORT_OK = qw( clone );
 sub import { goto &Exporter::import } 
 
 use vars qw( $CloneSelfMethod $CloneInitMethod );
 $CloneSelfMethod ||= 'clone_self';
 $CloneInitMethod ||= 'clone_init';
 
 use vars qw( %CloneCache );
 
 sub clone {
   my $source = shift;
 
   return undef if not defined($source);
   
   my $depth = shift;
   return $source if ( defined $depth and $depth -- < 1 );
   
   local %CloneCache = ( undef => undef ) unless ( exists $CloneCache{undef} );
   
   return $CloneCache{ $source } if ( defined $CloneCache{ $source } );
   
   my $ref_type = ref $source or return $source;
   
   my $class_name;
   if ( "$source" =~ /^\Q$ref_type\E\=([A-Z]+)\(0x[0-9a-f]+\)$/ ) {
     $class_name = $ref_type;
     $ref_type = $1;
     return $CloneCache{ $source } = $source->$CloneSelfMethod() 
 				  if $source->can($CloneSelfMethod);
   }
   
   
   my $copy;
   if ($ref_type eq 'HASH') {
     $CloneCache{ $source } = $copy = {};
     if ( my $tied = tied( %$source ) ) { tie %$copy, ref $tied }
     %$copy = map { ! ref($_) ? $_ : clone($_, $depth) } %$source;
   } elsif ($ref_type eq 'ARRAY') {
     $CloneCache{ $source } = $copy = [];
     if ( my $tied = tied( @$source ) ) { tie @$copy, ref $tied }
     @$copy = map { ! ref($_) ? $_ : clone($_, $depth) } @$source;
   } elsif ($ref_type eq 'REF' or $ref_type eq 'SCALAR') {
     $CloneCache{ $source } = $copy = \( my $var = "" );
     if ( my $tied = tied( $$source ) ) { tie $$copy, ref $tied }
     $$copy = clone($$source, $depth);
   } else {
     $CloneCache{ $source } = $copy = $source;
   }
   
   if ( $class_name ) {
     bless $copy, $class_name;
     $copy->$CloneInitMethod() if $copy->can($CloneInitMethod);
   }
   
   return $copy;
 }
 
 1;
 
 __END__
 
### Color/ANSI/Util.pm ###
 package Color::ANSI::Util;
 
 our $DATE = '2015-01-03'; 
 our $VERSION = '0.14'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(
                        ansi16_to_rgb
                        rgb_to_ansi16
                        rgb_to_ansi16_fg_code
                        ansi16fg
                        rgb_to_ansi16_bg_code
                        ansi16bg
 
                        ansi256_to_rgb
                        rgb_to_ansi256
                        rgb_to_ansi256_fg_code
                        ansi256fg
                        rgb_to_ansi256_bg_code
                        ansi256bg
 
                        rgb_to_ansi24b_fg_code
                        ansi24bfg
                        rgb_to_ansi24b_bg_code
                        ansi24bbg
 
                        rgb_to_ansi_fg_code
                        ansifg
                        rgb_to_ansi_bg_code
                        ansibg
                );
 
 my %ansi16 = (
     0  => '000000',
     1  => '800000',
     2  => '008000',
     3  => '808000',
     4  => '000080',
     5  => '800080',
     6  => '008080',
     7  => 'c0c0c0',
     8  => '808080',
     9  => 'ff0000',
     10 => '00ff00',
     11 => 'ffff00',
     12 => '0000ff',
     13 => 'ff00ff',
     14 => '00ffff',
     15 => 'ffffff',
 );
 my @revansi16;
 for (sort {$a<=>$b} keys %ansi16) {
     $ansi16{$_} =~ /(..)(..)(..)/;
     push @revansi16, [hex($1), hex($2), hex($3), $_];
 }
 
 my %ansi256 = (
     %ansi16,
 
     16 => '000000',  17 => '00005f',  18 => '000087',  19 => '0000af',  20 => '0000d7',  21 => '0000ff',
     22 => '005f00',  23 => '005f5f',  24 => '005f87',  25 => '005faf',  26 => '005fd7',  27 => '005fff',
     28 => '008700',  29 => '00875f',  30 => '008787',  31 => '0087af',  32 => '0087d7',  33 => '0087ff',
     34 => '00af00',  35 => '00af5f',  36 => '00af87',  37 => '00afaf',  38 => '00afd7',  39 => '00afff',
     40 => '00d700',  41 => '00d75f',  42 => '00d787',  43 => '00d7af',  44 => '00d7d7',  45 => '00d7ff',
     46 => '00ff00',  47 => '00ff5f',  48 => '00ff87',  49 => '00ffaf',  50 => '00ffd7',  51 => '00ffff',
     52 => '5f0000',  53 => '5f005f',  54 => '5f0087',  55 => '5f00af',  56 => '5f00d7',  57 => '5f00ff',
     58 => '5f5f00',  59 => '5f5f5f',  60 => '5f5f87',  61 => '5f5faf',  62 => '5f5fd7',  63 => '5f5fff',
     64 => '5f8700',  65 => '5f875f',  66 => '5f8787',  67 => '5f87af',  68 => '5f87d7',  69 => '5f87ff',
     70 => '5faf00',  71 => '5faf5f',  72 => '5faf87',  73 => '5fafaf',  74 => '5fafd7',  75 => '5fafff',
     76 => '5fd700',  77 => '5fd75f',  78 => '5fd787',  79 => '5fd7af',  80 => '5fd7d7',  81 => '5fd7ff',
     82 => '5fff00',  83 => '5fff5f',  84 => '5fff87',  85 => '5fffaf',  86 => '5fffd7',  87 => '5fffff',
     88 => '870000',  89 => '87005f',  90 => '870087',  91 => '8700af',  92 => '8700d7',  93 => '8700ff',
     94 => '875f00',  95 => '875f5f',  96 => '875f87',  97 => '875faf',  98 => '875fd7',  99 => '875fff',
     100 => '878700', 101 => '87875f', 102 => '878787', 103 => '8787af', 104 => '8787d7', 105 => '8787ff',
     106 => '87af00', 107 => '87af5f', 108 => '87af87', 109 => '87afaf', 110 => '87afd7', 111 => '87afff',
     112 => '87d700', 113 => '87d75f', 114 => '87d787', 115 => '87d7af', 116 => '87d7d7', 117 => '87d7ff',
     118 => '87ff00', 119 => '87ff5f', 120 => '87ff87', 121 => '87ffaf', 122 => '87ffd7', 123 => '87ffff',
     124 => 'af0000', 125 => 'af005f', 126 => 'af0087', 127 => 'af00af', 128 => 'af00d7', 129 => 'af00ff',
     130 => 'af5f00', 131 => 'af5f5f', 132 => 'af5f87', 133 => 'af5faf', 134 => 'af5fd7', 135 => 'af5fff',
     136 => 'af8700', 137 => 'af875f', 138 => 'af8787', 139 => 'af87af', 140 => 'af87d7', 141 => 'af87ff',
     142 => 'afaf00', 143 => 'afaf5f', 144 => 'afaf87', 145 => 'afafaf', 146 => 'afafd7', 147 => 'afafff',
     148 => 'afd700', 149 => 'afd75f', 150 => 'afd787', 151 => 'afd7af', 152 => 'afd7d7', 153 => 'afd7ff',
     154 => 'afff00', 155 => 'afff5f', 156 => 'afff87', 157 => 'afffaf', 158 => 'afffd7', 159 => 'afffff',
     160 => 'd70000', 161 => 'd7005f', 162 => 'd70087', 163 => 'd700af', 164 => 'd700d7', 165 => 'd700ff',
     166 => 'd75f00', 167 => 'd75f5f', 168 => 'd75f87', 169 => 'd75faf', 170 => 'd75fd7', 171 => 'd75fff',
     172 => 'd78700', 173 => 'd7875f', 174 => 'd78787', 175 => 'd787af', 176 => 'd787d7', 177 => 'd787ff',
     178 => 'd7af00', 179 => 'd7af5f', 180 => 'd7af87', 181 => 'd7afaf', 182 => 'd7afd7', 183 => 'd7afff',
     184 => 'd7d700', 185 => 'd7d75f', 186 => 'd7d787', 187 => 'd7d7af', 188 => 'd7d7d7', 189 => 'd7d7ff',
     190 => 'd7ff00', 191 => 'd7ff5f', 192 => 'd7ff87', 193 => 'd7ffaf', 194 => 'd7ffd7', 195 => 'd7ffff',
     196 => 'ff0000', 197 => 'ff005f', 198 => 'ff0087', 199 => 'ff00af', 200 => 'ff00d7', 201 => 'ff00ff',
     202 => 'ff5f00', 203 => 'ff5f5f', 204 => 'ff5f87', 205 => 'ff5faf', 206 => 'ff5fd7', 207 => 'ff5fff',
     208 => 'ff8700', 209 => 'ff875f', 210 => 'ff8787', 211 => 'ff87af', 212 => 'ff87d7', 213 => 'ff87ff',
     214 => 'ffaf00', 215 => 'ffaf5f', 216 => 'ffaf87', 217 => 'ffafaf', 218 => 'ffafd7', 219 => 'ffafff',
     220 => 'ffd700', 221 => 'ffd75f', 222 => 'ffd787', 223 => 'ffd7af', 224 => 'ffd7d7', 225 => 'ffd7ff',
     226 => 'ffff00', 227 => 'ffff5f', 228 => 'ffff87', 229 => 'ffffaf', 230 => 'ffffd7', 231 => 'ffffff',
 
     232 => '080808', 233 => '121212', 234 => '1c1c1c', 235 => '262626', 236 => '303030', 237 => '3a3a3a',
     238 => '444444', 239 => '4e4e4e', 240 => '585858', 241 => '606060', 242 => '666666', 243 => '767676',
     244 => '808080', 245 => '8a8a8a', 246 => '949494', 247 => '9e9e9e', 248 => 'a8a8a8', 249 => 'b2b2b2',
     250 => 'bcbcbc', 251 => 'c6c6c6', 252 => 'd0d0d0', 253 => 'dadada', 254 => 'e4e4e4', 255 => 'eeeeee',
 );
 my @revansi256;
 for (sort {$a<=>$b} keys %ansi256) {
     $ansi256{$_} =~ /(..)(..)(..)/;
     push @revansi256, [hex($1), hex($2), hex($3), $_];
 }
 
 sub ansi16_to_rgb {
     my ($input) = @_;
 
     if ($input =~ /^\d+$/) {
         if ($input >= 0 && $input <= 15) {
             return $ansi16{$input + 0}; 
         } else {
             die "Invalid ANSI 16-color number '$input'";
         }
     } elsif ($input =~ /^(?:(bold|bright) \s )?
                         (black|red|green|yellow|blue|magenta|cyan|white)$/ix) {
         my ($bold, $col) = (lc($1 // ""), lc($2));
         my $i;
         if ($col eq 'black') {
             $i = 0;
         } elsif ($col eq 'red') {
             $i = 1;
         } elsif ($col eq 'green') {
             $i = 2;
         } elsif ($col eq 'yellow') {
             $i = 3;
         } elsif ($col eq 'blue') {
             $i = 4;
         } elsif ($col eq 'magenta') {
             $i = 5;
         } elsif ($col eq 'cyan') {
             $i = 6;
         } elsif ($col eq 'white') {
             $i = 7;
         }
         $i += 8 if $bold;
         return $ansi16{$i};
     } else {
         die "Invalid ANSI 16-color name '$input'";
     }
 }
 
 sub _rgb_to_indexed {
     my ($rgb, $table) = @_;
 
     $rgb =~ /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/
         or die "Invalid RGB input '$rgb'";
     my $r = hex($1);
     my $g = hex($2);
     my $b = hex($3);
 
     my ($minsqdist, $res);
     for my $e (@$table) {
         my $sqdist =
             abs($e->[0]-$r)**2 + abs($e->[1]-$g)**2 + abs($e->[2]-$b)**2;
         return $e->[3] if $sqdist == 0;
         if (!defined($minsqdist) || $minsqdist > $sqdist) {
             $minsqdist = $sqdist;
             $res = $e->[3];
         }
     }
     return $res;
 }
 
 sub ansi256_to_rgb {
     my ($input) = @_;
 
     $input += 0;
     exists($ansi256{$input}) or die "Invalid ANSI 256-color index '$input'";
     $ansi256{$input};
 }
 
 sub rgb_to_ansi16 {
     my ($input) = @_;
     _rgb_to_indexed($input, \@revansi16);
 }
 
 sub rgb_to_ansi256 {
     my ($input) = @_;
     _rgb_to_indexed($input, \@revansi256);
 }
 
 sub rgb_to_ansi16_fg_code {
     my ($input) = @_;
 
     my $res = _rgb_to_indexed($input, \@revansi16);
     return "\e[" . ($res >= 8 ? ($res+30-8) . ";1" : ($res+30)) . "m";
 }
 
 sub ansi16fg  { goto &rgb_to_ansi16_fg_code  }
 
 sub rgb_to_ansi16_bg_code {
     my ($input) = @_;
 
     my $res = _rgb_to_indexed($input, \@revansi16);
     return "\e[" . ($res >= 8 ? ($res+40-8) : ($res+40)) . "m";
 }
 
 sub ansi16bg  { goto &rgb_to_ansi16_bg_code  }
 
 sub rgb_to_ansi256_fg_code {
     my ($input) = @_;
 
     my $res = _rgb_to_indexed($input, \@revansi16);
     return "\e[38;5;${res}m";
 }
 
 sub ansi256fg { goto &rgb_to_ansi256_fg_code }
 
 sub rgb_to_ansi256_bg_code {
     my ($input) = @_;
 
     my $res = _rgb_to_indexed($input, \@revansi16);
     return "\e[48;5;${res}m";
 }
 
 sub ansi256bg { goto &rgb_to_ansi256_bg_code }
 
 sub rgb_to_ansi24b_fg_code {
     my ($rgb) = @_;
 
     return sprintf("\e[38;2;%d;%d;%dm",
                    hex(substr($rgb, 0, 2)),
                    hex(substr($rgb, 2, 2)),
                    hex(substr($rgb, 4, 2)));
 }
 
 sub ansi24bfg { goto &rgb_to_ansi24b_fg_code }
 
 sub rgb_to_ansi24b_bg_code {
     my ($rgb) = @_;
 
     return sprintf("\e[48;2;%d;%d;%dm",
                    hex(substr($rgb, 0, 2)),
                    hex(substr($rgb, 2, 2)),
                    hex(substr($rgb, 4, 2)));
 }
 
 sub ansi24bbg { goto &rgb_to_ansi24b_bg_code }
 
 our $_use_termdetsw = 1;
 our $_color_depth; 
 sub _color_depth {
     unless (defined $_color_depth) {
         {
             if (defined $ENV{COLOR_DEPTH}) {
                 $_color_depth = $ENV{COLOR_DEPTH};
                 last;
             }
             if ($_use_termdetsw) {
                 eval { require Term::Detect::Software };
                 if (!$@) {
                     $_color_depth = Term::Detect::Software::detect_terminal_cached()->{color_depth};
                     last;
                 }
             }
             if ($ENV{KONSOLE_DBUS_SERVICE}) {
                 $_color_depth = 2**24;
                 last;
             }
             $_color_depth = 16;
         }
     };
     $_color_depth;
 }
 
 sub rgb_to_ansi_fg_code {
     my ($rgb) = @_;
     my $cd = _color_depth();
     if ($cd >= 2**24) {
         rgb_to_ansi24b_fg_code($rgb);
     } elsif ($cd >= 256) {
         rgb_to_ansi256_fg_code($rgb);
     } else {
         rgb_to_ansi16_fg_code($rgb);
     }
 }
 
 sub ansifg { goto &rgb_to_ansi_fg_code }
 
 sub rgb_to_ansi_bg_code {
     my ($rgb) = @_;
     my $cd = _color_depth();
     if ($cd >= 2**24) {
         rgb_to_ansi24b_bg_code($rgb);
     } elsif ($cd >= 256) {
         rgb_to_ansi256_bg_code($rgb);
     } else {
         rgb_to_ansi16_bg_code($rgb);
     }
 }
 
 sub ansibg { goto &rgb_to_ansi_bg_code }
 
 1;
 
 __END__
 
### Color/RGB/Util.pm ###
 package Color::RGB::Util;
 
 our $DATE = '2015-01-03'; 
 our $VERSION = '0.58'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        mix_2_rgb_colors
                        rand_rgb_color
                        reverse_rgb_color
                        rgb2grayscale
                        rgb2sepia
                        rgb_luminance
                        tint_rgb_color
                );
 
 sub mix_2_rgb_colors {
     my ($rgb1, $rgb2, $pct) = @_;
 
     $pct //= 0.5;
 
     $rgb1 =~ /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/o
         or die "Invalid rgb1 color, must be in 'ffffff' form";
     my $r1 = hex($1);
     my $g1 = hex($2);
     my $b1 = hex($3);
     $rgb2 =~ /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/o
         or die "Invalid rgb2 color, must be in 'ffffff' form";
     my $r2 = hex($1);
     my $g2 = hex($2);
     my $b2 = hex($3);
 
     return sprintf("%02x%02x%02x",
                    $r1 + $pct*($r2-$r1),
                    $g1 + $pct*($g2-$g1),
                    $b1 + $pct*($b2-$b1),
                );
 }
 
 sub rand_rgb_color {
     my ($rgb1, $rgb2) = @_;
 
     $rgb1 //= '000000';
     $rgb1 =~ /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/o
         or die "Invalid rgb1 color, must be in 'ffffff' form";
     my $r1 = hex($1);
     my $g1 = hex($2);
     my $b1 = hex($3);
     $rgb2 //= 'ffffff';
     $rgb2 =~ /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/o
         or die "Invalid rgb2 color, must be in 'ffffff' form";
     my $r2 = hex($1);
     my $g2 = hex($2);
     my $b2 = hex($3);
 
     return sprintf("%02x%02x%02x",
                    $r1 + rand()*($r2-$r1+1),
                    $g1 + rand()*($g2-$g1+1),
                    $b1 + rand()*($b2-$b1+1),
                );
 }
 
 sub rgb2grayscale {
     my ($rgb) = @_;
 
     $rgb =~ /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/o
         or die "Invalid rgb color, must be in 'ffffff' form";
     my $r = hex($1);
     my $g = hex($2);
     my $b = hex($3);
 
     my $avg = int(($r + $g + $b)/3);
     return sprintf("%02x%02x%02x", $avg, $avg, $avg);
 }
 
 sub rgb2sepia {
     my ($rgb) = @_;
 
     $rgb =~ /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/o
         or die "Invalid rgb color, must be in 'ffffff' form";
     my $r = hex($1);
     my $g = hex($2);
     my $b = hex($3);
 
     my $or = ($r*0.393) + ($g*0.769) + ($b*0.189);
     my $og = ($r*0.349) + ($g*0.686) + ($b*0.168);
     my $ob = ($r*0.272) + ($g*0.534) + ($b*0.131);
     for ($or, $og, $ob) { $_ = 255 if $_ > 255 }
     return sprintf("%02x%02x%02x", $or, $og, $ob);
 }
 
 sub reverse_rgb_color {
     my ($rgb) = @_;
 
     $rgb =~ /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/o
         or die "Invalid rgb color, must be in 'ffffff' form";
     my $r = hex($1);
     my $g = hex($2);
     my $b = hex($3);
 
     return sprintf("%02x%02x%02x", 255-$r, 255-$g, 255-$b);
 }
 
 sub _rgb_luminance {
     my ($r, $g, $b) = @_;
     0.2126*$r/255 + 0.7152*$g/255 + 0.0722*$b/255;
 }
 
 sub rgb_luminance {
     my ($rgb) = @_;
 
     $rgb =~ /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/o
         or die "Invalid rgb color, must be in 'ffffff' form";
     my $r = hex($1);
     my $g = hex($2);
     my $b = hex($3);
 
     return _rgb_luminance($r, $g, $b);
 }
 
 sub tint_rgb_color {
     my ($rgb1, $rgb2, $pct) = @_;
 
     $pct //= 0.5;
 
     $rgb1 =~ /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/o
         or die "Invalid rgb color, must be in 'ffffff' form";
     my $r1 = hex($1);
     my $g1 = hex($2);
     my $b1 = hex($3);
     $rgb2 =~ /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/o
         or die "Invalid tint color, must be in 'ffffff' form";
     my $r2 = hex($1);
     my $g2 = hex($2);
     my $b2 = hex($3);
 
     my $lum = _rgb_luminance($r1, $g1, $b1);
 
     return sprintf("%02x%02x%02x",
                    $r1 + $pct*($r2-$r1)*$lum,
                    $g1 + $pct*($g2-$g1)*$lum,
                    $b1 + $pct*($b2-$b1)*$lum,
                );
 }
 
 1;
 
 __END__
 
### Color/Theme.pm ###
 package Color::Theme;
 
 our $DATE = '2014-12-11'; 
 our $VERSION = '0.01'; 
 
 1;
 
 __END__
 
### Color/Theme/Role.pm ###
 package Color::Theme::Role;
 
 our $DATE = '2014-12-11'; 
 our $VERSION = '0.01'; 
 
 use 5.010001;
 use Moo::Role;
 
 has color_theme_args  => (is => 'rw', default => sub { {} });
 has _all_color_themes => (is => 'rw');
 
 sub color_theme_module_prefix {
     my $self = shift;
 
     (ref($self) ? ref($self) : $self ) . '::ColorTheme';
 }
 
 sub color_theme {
     my $self = shift;
 
     if (!@_) { return $self->{color_theme} }
     my $ct = shift;
 
     my $p2 = "";
     if (!ref($ct)) {
         $p2 = " named $ct";
         $ct = $self->get_color_theme($ct);
     }
 
     my $err;
     if (!$ct->{no_color} && !$self->use_color) {
         $err = "color theme uses color but use_color is set to false";
     }
     die "Can't select color theme$p2: $err" if $err;
 
     $self->{color_theme} = $ct;
 }
 
 sub get_color_theme {
     my ($self, $ct) = @_;
 
     my $prefix = $self->color_theme_module_prefix;
     my $cts;
     my $pkg;
     if ($ct =~ s/(.+):://) {
         $pkg = "$prefix\::$1";
         my $pkgp = $pkg; $pkgp =~ s!::!/!g;
         require "$pkgp.pm";
         no strict 'refs';
         $cts = \%{"$pkg\::color_themes"};
     } else {
         die "Please use SubPackage::name to choose color theme, ".
             "use list_color_themes() to list available themes";
     }
     $cts->{$ct} or die "Unknown color theme name '$ct'".
         ($pkg ? " in package $pkg" : "");
     ($cts->{$ct}{v} // 1.0) == 1.1 or die "Color theme '$ct' is too old ".
         "(v < 1.1)". ($pkg ? ", please upgrade $pkg" : "");
     $cts->{$ct};
 }
 
 sub get_theme_color {
     my ($self, $item_name) = @_;
 
     return undef if $self->{color_theme}{no_color};
     $self->{color_theme}{colors}{$item_name};
 }
 
 sub get_theme_color_as_rgb {
     my ($self, $item_name, $args) = @_;
     my $c = $self->get_theme_color($item_name);
     return undef unless defined($c);
 
     if (ref($c) eq 'CODE') {
         $args //= {};
         $c = $c->($self, %$args);
     }
 
     $c;
 }
 
 sub list_color_themes {
     require Module::List;
     require Module::Load;
 
     my ($self, $detail) = @_;
 
     my $prefix = $self->color_theme_module_prefix;
     my $all_ct = $self->_all_color_themes;
 
     if (!$all_ct) {
         my $mods = Module::List::list_modules("$prefix\::",
                                               {list_modules=>1, recurse=>1});
         no strict 'refs';
         $all_ct = {};
         for my $mod (sort keys %$mods) {
             Module::Load::load($mod);
             my $ct = \%{"$mod\::color_themes"};
             for (keys %$ct) {
                 my $cutmod = $mod;
                 $cutmod =~ s/^\Q$prefix\E:://;
                 my $name = "$cutmod\::$_";
                 $ct->{$_}{name} = $name;
                 $all_ct->{$name} = $ct->{$_};
             }
         }
         $self->_all_color_themes($all_ct);
     }
 
     if ($detail) {
         return $all_ct;
     } else {
         return sort keys %$all_ct;
     }
 }
 
 1;
 
 __END__
 
### Color/Theme/Role/ANSI.pm ###
 package Color::Theme::Role::ANSI;
 
 our $DATE = '2014-12-11'; 
 our $VERSION = '0.01'; 
 
 use 5.010001;
 use Moo::Role;
 
 use Color::ANSI::Util ();
 with 'Color::Theme::Role';
 with 'Term::App::Role::Attrs';
 
 sub theme_color_to_ansi {
     my ($self, $c, $args, $is_bg) = @_;
 
     return '' if !defined($c) || !length($c);
 
     if (ref($c) eq 'CODE') {
         $args //= {};
         $c = $c->($self, %$args);
     }
 
     my $coldepth = $self->color_depth;
 
     if ($coldepth >= 2**24) {
         if (ref $c) {
             my $ansifg = $c->{ansi_fg};
             $ansifg //= Color::ANSI::Util::ansi24bfg($c->{fg})
                 if defined $c->{fg};
             $ansifg //= "";
             my $ansibg = $c->{ansi_bg};
             $ansibg //= Color::ANSI::Util::ansi24bbg($c->{bg})
                 if defined $c->{bg};
             $ansibg //= "";
             $c = $ansifg . $ansibg;
         } else {
             $c = $is_bg ? Color::ANSI::Util::ansi24bbg($c) :
                 Color::ANSI::Util::ansi24bfg($c);
         }
     } elsif ($coldepth >= 256) {
         if (ref $c) {
             my $ansifg = $c->{ansi_fg};
             $ansifg //= Color::ANSI::Util::ansi256fg($c->{fg})
                 if defined $c->{fg};
             $ansifg //= "";
             my $ansibg = $c->{ansi_bg};
             $ansibg //= Color::ANSI::Util::ansi256bg($c->{bg})
                 if defined $c->{bg};
             $ansibg //= "";
             $c = $ansifg . $ansibg;
         } else {
             $c = $is_bg ? Color::ANSI::Util::ansi256bg($c) :
                 Color::ANSI::Util::ansi256fg($c);
         }
     } else {
         if (ref $c) {
             my $ansifg = $c->{ansi_fg};
             $ansifg //= Color::ANSI::Util::ansi16fg($c->{fg})
                 if defined $c->{fg};
             $ansifg //= "";
             my $ansibg = $c->{ansi_bg};
             $ansibg //= Color::ANSI::Util::ansi16bg($c->{bg})
                 if defined $c->{bg};
             $ansibg //= "";
             $c = $ansifg . $ansibg;
         } else {
             $c = $is_bg ? Color::ANSI::Util::ansi16bg($c) :
                 Color::ANSI::Util::ansi16fg($c);
         }
     }
     $c;
 }
 
 sub get_theme_color_as_ansi {
     my ($self, $item_name, $args) = @_;
     $self->theme_color_to_ansi(
         $self->get_theme_color($item_name),
         {name=>$item_name, %{ $args // {} }},
         $item_name =~ /_bg$/,
     );
 }
 
 1;
 
 __END__
 
### Color/Theme/Util.pm ###
 package Color::Theme::Util;
 
 our $DATE = '2014-12-11'; 
 our $VERSION = '0.01'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(create_color_theme_transform);
 
 sub create_color_theme_transform {
     my ($basect, $func) = @_;
 
     my $derivedct = {};
 
     for my $cn (keys %{ $basect->{colors} }) {
         my $cv = $basect->{colors}{$cn};
 
         if ($cv) {
             $derivedct->{colors}{$cn} = sub {
                 my ($self, %args) = @_;
                 my $basec = $basect->{colors}{$cn};
                 if (ref($basec) eq 'CODE') {
                     $basec = $basec->($self, name=>$cn, %args);
                 }
                 if ($basec) {
                     if (ref($basec) eq 'ARRAY') {
                         $basec = [map {defined($_) && /^#?[0-9A-Fa-f]{6}$/ ?
                                            $func->($_) : $_} @$basec];
                     } else {
                         for ($basec) {
                             $_ = defined($_) && /^#?[0-9A-Fa-f]{6}$/ ?
                                 $func->($_) : $_;
                         }
                     }
                 }
                 return $basec;
             };
         } else {
         }
     }
     $derivedct;
 }
 
 1;
 
 __END__
 
### Complete.pm ###
 package Complete;
 
 our $DATE = '2015-09-16'; 
 our $VERSION = '0.16'; 
 
 1;
 
 __END__
 
### Complete/Bash.pm ###
 package Complete::Bash;
 
 our $DATE = '2015-09-09'; 
 our $VERSION = '0.21'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        parse_cmdline
                        parse_options
                        format_completion
                );
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'Completion module for bash shell',
     links => [
         {url => 'pm:Complete'},
     ],
 };
 
 sub _expand_tilde {
     my ($user, $slash) = @_;
     my @ent;
     if (length $user) {
         @ent = getpwnam($user);
     } else {
         @ent = getpwuid($>);
         $user = $ent[0];
     }
     return $ent[7] . $slash if @ent;
     "~$user$slash"; 
 }
 
 sub _add_unquoted {
     no warnings 'uninitialized';
 
     my ($word, $is_cur_word, $after_ws) = @_;
 
 
     $word =~ s!^(~)(\w*)(/|\z) |  # 1) tilde  2) username  3) optional slash
                \\(.)           |  # 4) escaped char
                \$(\w+)            # 5) variable name
               !
                   $1 ? (not($after_ws) || $is_cur_word ? "$1$2$3" : _expand_tilde($2, $3)) :
                       $4 ? $4 :
                           ($is_cur_word ? "\$$5" : $ENV{$5})
                               !egx;
     $word;
 }
 
 sub _add_double_quoted {
     no warnings 'uninitialized';
 
     my ($word, $is_cur_word) = @_;
 
     $word =~ s!\\(.)           |  # 1) escaped char
                \$(\w+)            # 2) variable name
               !
                   $1 ? $1 :
                       ($is_cur_word ? "\$$2" : $ENV{$2})
                           !egx;
     $word;
 }
 
 sub _add_single_quoted {
     my $word = shift;
     $word =~ s/\\(.)/$1/g;
     $word;
 }
 
 $SPEC{parse_cmdline} = {
     v => 1.1,
     summary => 'Parse shell command-line for processing by completion routines',
     description => <<'_',
 
 This function basically converts COMP_LINE (str) and COMP_POINT (int) into
 something like (but not exactly the same as) COMP_WORDS (array) and COMP_CWORD
 (int) that bash supplies to shell functions.
 
 The differences with bash are (these differences are mostly for parsing
 convenience for programs that use this routine):
 
 1) quotes and backslashes are stripped (bash's COMP_WORDS contains all the
 quotes and backslashes);
 
 2) variables are substituted with their values from environment variables except
 for the current word (COMP_WORDS[COMP_CWORD]) (bash does not perform variable
 substitution for COMP_WORDS). However, note that special shell variables that
 are not environment variables like `$0`, `$_`, `$IFS` will not be replaced
 correctly because bash does not export those variables for us.
 
 3) tildes (~) are expanded with user's home directory except for the current
 word (bash does not perform tilde expansion for COMP_WORDS);
 
 4) no word-breaking characters aside from whitespaces and `=` are currently used
 (bash uses COMP_WORDBREAKS which by default also include `:`, `;`, and so on).
 This is done for convenience of parsing of Getopt::Long-based applications. More
 word-breaking characters might be used in the future, e.g. when we want to
 handle complex bash statements like pipes, redirection, etc.
 
 Caveats:
 
 * Due to the way bash parses the command line, the two below are equivalent:
 
     % cmd --foo=bar
     % cmd --foo = bar
 
 Because they both expand to `['--foo', '=', 'bar']`. But obviously
 `Getopt::Long` does not regard the two as equivalent.
 
 _
     args_as => 'array',
     args => {
         cmdline => {
             summary => 'Command-line, defaults to COMP_LINE environment',
             schema => 'str*',
             pos => 0,
         },
         point => {
             summary => 'Point/position to complete in command-line, '.
                 'defaults to COMP_POINT',
             schema => 'int*',
             pos => 1,
         },
     },
     result => {
         schema => ['array*', len=>2],
         description => <<'_',
 
 Return a 2-element array: `[$words, $cword]`. `$words` is array of str,
 equivalent to `COMP_WORDS` provided by bash to shell functions. `$cword` is an
 integer, equivalent to `COMP_CWORD` provided by bash to shell functions. The
 word to be completed is at `$words->[$cword]`.
 
 Note that COMP_LINE includes the command name. If you want the command-line
 arguments only (like in `@ARGV`), you need to strip the first element from
 `$words` and reduce `$cword` by 1.
 
 
 _
     },
     result_naked => 1,
     links => [
     ],
 };
 sub parse_cmdline {
     no warnings 'uninitialized';
     my ($line, $point) = @_;
 
     $line  //= $ENV{COMP_LINE};
     $point //= $ENV{COMP_POINT} // 0;
 
     die "$0: COMP_LINE not set, make sure this script is run under ".
         "bash completion (e.g. through complete -C)\n" unless defined $line;
 
     my @words;
     my $cword;
     my $pos = 0;
     my $pos_min_ws = 0;
     my $after_ws = 1;
     my $chunk;
     my $add_blank;
     my $is_cur_word;
     $line =~ s!(                                                 # 1) everything
                   (")((?: \\\\|\\"|[^"])*)(?:"|\z)(\s*)       |  # 2) open "  3) content  4) space after
                   (')((?: \\\\|\\'|[^'])*)(?:'|\z)(\s*)       |  # 5) open '  6) content  7) space after
                   ((?: \\\\|\\"|\\'|\\=|\\\s|[^"'=\s])+)(\s*) |  # 8) unquoted word  9) space after
                   = |
                   \s+
               )!
                   $pos += length($1);
                   #say "D:<$1> pos=$pos, point=$point, cword=$cword, after_ws=$after_ws";
 
                   if ($2 || $5 || defined($8)) {
                       # double-quoted/single-quoted/unquoted chunk
 
                       if (not(defined $cword)) {
                           $pos_min_ws = $pos - length($2 ? $4 : $5 ? $7 : $9);
                           #say "D:pos_min_ws=$pos_min_ws";
                           if ($point <= $pos_min_ws) {
                               $cword = @words - ($after_ws ? 0 : 1);
                           } elsif ($point < $pos) {
                               $cword = @words + 1 - ($after_ws ? 0 : 1);
                               $add_blank = 1;
                           }
                       }
 
                       if ($after_ws) {
                           $is_cur_word = defined($cword) && $cword==@words;
                       } else {
                           $is_cur_word = defined($cword) && $cword==@words-1;
                       }
                       $chunk =
                           $2 ? _add_double_quoted($3, $is_cur_word) :
                               $5 ? _add_single_quoted($6) :
                                   _add_unquoted($8, $is_cur_word, $after_ws);
                       if ($after_ws) {
                           push @words, $chunk;
                       } else {
                           $words[-1] .= $chunk;
                       }
                       if ($add_blank) {
                           push @words, '';
                           $add_blank = 0;
                       }
                       $after_ws = ($2 ? $4 : $5 ? $7 : $9) ? 1:0;
 
                   } elsif ($1 eq '=') {
                       # equal sign as word-breaking character
                       push @words, '=';
                       $after_ws = 1;
                   } else {
                       # whitespace
                       $after_ws = 1;
                   }
     !egx;
 
     $cword //= @words;
     $words[$cword] //= '';
 
     [\@words, $cword];
 }
 
 $SPEC{parse_options} = {
     v => 1.1,
     summary => 'Parse command-line for options and arguments, '.
         'more or less like Getopt::Long',
     description => <<'_',
 
 Parse command-line into words using `parse_cmdline()` then separate options and
 arguments. Since this routine does not accept `Getopt::Long` (this routine is
 meant to be a generic option parsing of command-lines), it uses a few simple
 rules to server the common cases:
 
 * After `--`, the rest of the words are arguments (just like Getopt::Long).
 
 * If we get something like `-abc` (a single dash followed by several letters) it
   is assumed to be a bundle of short options.
 
 * If we get something like `-MData::Dump` (a single dash, followed by a letter,
   followed by some letters *and* non-letters/numbers) it is assumed to be an
   option (`-M`) followed by a value.
 
 * If we get something like `--foo` it is a long option. If the next word is an
   option (starts with a `-`) then it is assumed that this option does not have
   argument. Otherwise, the next word is assumed to be this option's value.
 
 * Otherwise, it is an argument (that is, permute is assumed).
 
 _
 
     args => {
         cmdline => {
             summary => 'Command-line, defaults to COMP_LINE environment',
             schema => 'str*',
         },
         point => {
             summary => 'Point/position to complete in command-line, '.
                 'defaults to COMP_POINT',
             schema => 'int*',
         },
         words => {
             summary => 'Alternative to passing `cmdline` and `point`',
             schema => ['array*', of=>'str*'],
             description => <<'_',
 
 If you already did a `parse_cmdline()`, you can pass the words result (the first
 element) here to avoid calling `parse_cmdline()` twice.
 
 _
         },
         cword => {
             summary => 'Alternative to passing `cmdline` and `point`',
             schema => ['array*', of=>'str*'],
             description => <<'_',
 
 If you already did a `parse_cmdline()`, you can pass the cword result (the
 second element) here to avoid calling `parse_cmdline()` twice.
 
 _
         },
     },
     result => {
         schema => 'hash*',
     },
 };
 sub parse_options {
     my %args = @_;
 
     my ($words, $cword) = @_;
     if ($args{words}) {
         ($words, $cword) = ($args{words}, $args{cword});
     } else {
         ($words, $cword) = @{parse_cmdline($args{cmdline}, $args{point}, '=')};
     }
 
     my @types;
     my %opts;
     my @argv;
     my $type;
     $types[0] = 'command';
     my $i = 1;
     while ($i < @$words) {
         my $word = $words->[$i];
         if ($word eq '--') {
             if ($i == $cword) {
                 $types[$i] = 'opt_name';
                 $i++; next;
             }
             $types[$i] = 'separator';
             for ($i+1 .. @$words-1) {
                 $types[$_] = 'arg,' . @argv;
                 push @argv, $words->[$_];
             }
             last;
         } elsif ($word =~ /\A-(\w*)\z/) {
             $types[$i] = 'opt_name';
             for (split '', $1) {
                 push @{ $opts{$_} }, undef;
             }
             $i++; next;
         } elsif ($word =~ /\A-([\w?])(.*)/) {
             $types[$i] = 'opt_name';
             push @{ $opts{$1} }, $2;
             $i++; next;
         } elsif ($word =~ /\A--(\w[\w-]*)\z/) {
             $types[$i] = 'opt_name';
             my $opt = $1;
             $i++;
             if ($i < @$words) {
                 if ($words->[$i] eq '=') {
                     $types[$i] = 'separator';
                     $i++;
                 }
                 if ($words->[$i] =~ /\A-/) {
                     push @{ $opts{$opt} }, undef;
                     next;
                 }
                 $types[$i] = 'opt_val';
                 push @{ $opts{$opt} }, $words->[$i];
                 $i++; next;
             }
         } else {
             $types[$i] = 'arg,' . @argv;
             push @argv, $word;
             $i++; next;
         }
     }
 
     return {
         opts      => \%opts,
         argv      => \@argv,
         cword     => $cword,
         words     => $words,
         word_type => $types[$cword],
     };
 }
 
 $SPEC{format_completion} = {
     v => 1.1,
     summary => 'Format completion for output (for shell)',
     description => <<'_',
 
 Bash accepts completion reply in the form of one entry per line to STDOUT. Some
 characters will need to be escaped. This function helps you do the formatting,
 with some options.
 
 This function accepts completion answer structure as described in the `Complete`
 POD. Aside from `words`, this function also recognizes these keys:
 
 * `as` (str): Either `string` (the default) or `array` (to return array of lines
   instead of the lines joined together). Returning array is useful if you are
   doing completion inside `Term::ReadLine`, for example, where the library
   expects an array.
 
 * `esc_mode` (str): Escaping mode for entries. Either `default` (most
   nonalphanumeric characters will be escaped), `shellvar` (like `default`, but
   dollar sign `$` will not be escaped, convenient when completing environment
   variables for example), `filename` (currently equals to `default`), `option`
   (currently equals to `default`), or `none` (no escaping will be done).
 
 * `path_sep` (str): If set, will enable "path mode", useful for
   completing/drilling-down path. Below is the description of "path mode".
 
   In shell, when completing filename (e.g. `foo`) and there is only a single
   possible completion (e.g. `foo` or `foo.txt`), the shell will display the
   completion in the buffer and automatically add a space so the user can move to
   the next argument. This is also true when completing other values like
   variables or program names.
 
   However, when completing directory (e.g. `/et` or `Downloads`) and there is
   solely a single completion possible and it is a directory (e.g. `/etc` or
   `Downloads`), the shell automatically adds the path separator character
   instead (`/etc/` or `Downloads/`). The user can press Tab again to complete
   for files/directories inside that directory, and so on. This is obviously more
   convenient compared to when shell adds a space instead.
 
   The `path_sep` option, when set, will employ a trick to mimic this behaviour.
   The trick is, if you have a completion array of `['foo/']`, it will be changed
   to `['foo/', 'foo/ ']` (the second element is the first element with added
   space at the end) to prevent bash from adding a space automatically.
 
   Path mode is not restricted to completing filesystem paths. Anything path-like
   can use it. For example when you are completing Java or Perl module name (e.g.
   `com.company.product.whatever` or `File::Spec::Unix`) you can use this mode
   (with `path_sep` appropriately set to, e.g. `.` or `::`).
 
 _
     args_as => 'array',
     args => {
         completion => {
             summary => 'Completion answer structure',
             description => <<'_',
 
 Either an array or hash. See function description for more details.
 
 _
             schema=>['any*' => of => ['hash*', 'array*']],
             req=>1,
             pos=>0,
         },
         opts => {
             schema=>'hash*',
             pos=>1,
         },
     },
     result => {
         summary => 'Formatted string (or array, if `as` is set to `array`)',
         schema => ['any*' => of => ['str*', 'array*']],
     },
     result_naked => 1,
 };
 sub format_completion {
     my ($hcomp, $opts) = @_;
 
     $opts //= {};
 
     $hcomp = {words=>$hcomp} unless ref($hcomp) eq 'HASH';
     my $comp     = $hcomp->{words};
     my $as       = $hcomp->{as} // 'string';
     my $esc_mode = $hcomp->{esc_mode} // $hcomp->{escmode} // 'default';
     my $path_sep = $hcomp->{path_sep};
 
     if (defined($path_sep) && @$comp == 1) {
         my $re = qr/\Q$path_sep\E\z/;
         my $word;
         if (ref($comp->[0]) eq 'HASH') {
             $comp = [$comp->[0], {word=>"$comp->[0] "}] if
                 $comp->[0]{word} =~ $re;
         } else {
             $comp = [$comp->[0], "$comp->[0] "]
                 if $comp->[0] =~ $re;
         }
     }
 
     if (defined($opts->{word})) {
         if ($opts->{word} =~ s/(.+:)//) {
             my $prefix = $1;
             for (@$comp) {
                 if (ref($_) eq 'HASH') {
                     $_->{word} =~ s/\A\Q$prefix\E//i;
                 } else {
                     s/\A\Q$prefix\E//i;
                 }
             }
         }
     }
 
     my @res;
     for my $entry (@$comp) {
         my $word = ref($entry) eq 'HASH' ? $entry->{word} : $entry;
         if ($esc_mode eq 'shellvar') {
             $word =~ s!([^A-Za-z0-9,+._/\$~-])!\\$1!g;
         } elsif ($esc_mode eq 'none') {
         } else {
             $word =~ s!([^A-Za-z0-9,+._/:~-])!\\$1!g;
         }
         push @res, $word;
     }
 
     if ($as eq 'array') {
         return \@res;
     } else {
         return join("", map {($_, "\n")} @res);
     }
 }
 
 1;
 
 __END__
 
### Complete/Env.pm ###
 package Complete::Env;
 
 our $DATE = '2015-09-17'; 
 our $VERSION = '0.37'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Complete::Setting;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        complete_env
                );
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'Completion routines related to environment variables',
 };
 
 $SPEC{complete_env} = {
     v => 1.1,
     summary => 'Complete from environment variables',
     description => <<'_',
 
 On Windows, environment variable names are all converted to uppercase. You can
 use case-insensitive option (`ci`) to match against original casing.
 
 _
     args => {
         word     => { schema=>[str=>{default=>''}], pos=>0, req=>1 },
         ci       => { schema=>['bool'] },
         fuzzy    => { schema=>['int*', min=>0] },
         map_case => { schema=>['bool'] },
     },
     result_naked => 1,
     result => {
         schema => 'array',
     },
 };
 sub complete_env {
     require Complete::Util;
 
     my %args  = @_;
     my $word     = $args{word} // "";
     my $ci       = $args{ci} // $Complete::Setting::OPT_CI;
     my $fuzzy    = $args{fuzzy} // $Complete::Setting::OPT_FUZZY;
     my $map_case = $args{map_case} // $Complete::Setting::OPT_MAP_CASE;
     if ($word =~ /^\$/) {
         Complete::Util::complete_array_elem(
             word=>$word, array=>[map {"\$$_"} keys %ENV],
             ci=>$ci, fuzzy=>$fuzzy, map_case=>$map_case);
     } else {
         Complete::Util::complete_array_elem(
             word=>$word, array=>[keys %ENV],
             ci=>$ci, fuzzy=>$fuzzy, map_case=>$map_case);
     }
 }
 1;
 
 __END__
 
### Complete/File.pm ###
 package Complete::File;
 
 our $DATE = '2015-09-20'; 
 our $VERSION = '0.37'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Complete::Setting;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        complete_file
                );
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'Completion routines related to files',
 };
 
 $SPEC{complete_file} = {
     v => 1.1,
     summary => 'Complete file and directory from local filesystem',
     args_rels => {
         choose_one => [qw/filter file_regex_filter/],
     },
     args => {
         word => {
             schema  => [str=>{default=>''}],
             req     => 1,
             pos     => 0,
         },
         ci => {
             summary => 'Case-insensitive matching',
             schema  => 'bool',
         },
         fuzzy => {
             summary => 'Fuzzy matching',
             schema  => ['int*', min=>0],
         },
         map_case => {
             schema  => 'bool',
         },
         exp_im_path => {
             schema  => 'bool',
         },
         dig_leaf => {
             schema  => 'bool',
         },
         filter => {
             summary => 'Only return items matching this filter',
             description => <<'_',
 
 Filter can either be a string or a code.
 
 For string filter, you can specify a pipe-separated groups of sequences of these
 characters: f, d, r, w, x. Dash can appear anywhere in the sequence to mean
 not/negate. An example: `f` means to only show regular files, `-f` means only
 show non-regular files, `drwx` means to show only directories which are
 readable, writable, and executable (cd-able). `wf|wd` means writable regular
 files or writable directories.
 
 For code filter, you supply a coderef. The coderef will be called for each item
 with these arguments: `$name`. It should return true if it wants the item to be
 included.
 
 _
             schema  => ['any*' => {of => ['str*', 'code*']}],
         },
         file_regex_filter => {
             summary => 'Filter shortcut for file regex',
             description => <<'_',
 
 This is a shortcut for constructing a filter. So instead of using `filter`, you
 use this option. This will construct a filter of including only directories or
 regular files, and the file must match a regex pattern. This use-case is common.
 
 _
             schema => 're*',
         },
         starting_path => {
             schema  => 'str*',
             default => '.',
         },
         handle_tilde => {
             schema  => 'bool',
             default => 1,
         },
         allow_dot => {
             summary => 'If turned off, will not allow "." or ".." in path',
             description => <<'_',
 
 This is most useful when combined with `starting_path` option to prevent user
 going up/outside the starting path.
 
 _
             schema  => 'bool',
             default => 1,
         },
     },
     result_naked => 1,
     result => {
         schema => 'array',
     },
 };
 sub complete_file {
     require Complete::Path;
     require File::Glob;
 
     my %args   = @_;
     my $word   = $args{word} // "";
     my $ci          = $args{ci} // $Complete::Setting::OPT_CI;
     my $fuzzy       = $args{fuzzy} // $Complete::Setting::OPT_FUZZY;
     my $map_case    = $args{map_case} // $Complete::Setting::OPT_MAP_CASE;
     my $exp_im_path = $args{exp_im_path} // $Complete::Setting::OPT_EXP_IM_PATH;
     my $dig_leaf    = $args{dig_leaf} // $Complete::Setting::OPT_DIG_LEAF;
     my $handle_tilde = $args{handle_tilde} // 1;
     my $allow_dot   = $args{allow_dot} // 1;
     my $filter = $args{filter};
 
     my $result_prefix;
     my $starting_path = $args{starting_path} // '.';
     if ($handle_tilde && $word =~ s!\A(~[^/]*)/!!) {
         $result_prefix = "$1/";
         my @dir = File::Glob::glob($1); 
         return [] unless @dir;
         $starting_path = $dir[0];
     } elsif ($allow_dot && $word =~ s!\A((?:\.\.?/+)+|/+)!!) {
         $starting_path = $1;
         $result_prefix = $1;
         $starting_path =~ s#/+\z## unless $starting_path =~ m!\A/!;
     }
 
     return [] if !$allow_dot &&
         $word =~ m!(?:\A|/)\.\.?(?:\z|/)!;
 
     my $list = sub {
         my ($path, $intdir, $isint) = @_;
         opendir my($dh), $path or return undef;
         my @res;
         for (sort readdir $dh) {
             next if ($_ eq '.' || $_ eq '..') && $intdir eq '';
             next if $isint && !(-d "$path/$_");
             push @res, $_;
         }
         \@res;
     };
 
     if ($filter && !ref($filter)) {
         my @seqs = split /\s*\|\s*/, $filter;
         $filter = sub {
             my $name = shift;
             my @st = stat($name) or return 0;
             my $mode = $st[2];
             my $pass;
           SEQ:
             for my $seq (@seqs) {
                 my $neg = sub { $_[0] };
                 for my $c (split //, $seq) {
                     if    ($c eq '-') { $neg = sub { $_[0] ? 0 : 1 } }
                     elsif ($c eq 'r') { next SEQ unless $neg->($mode & 0400) }
                     elsif ($c eq 'w') { next SEQ unless $neg->($mode & 0200) }
                     elsif ($c eq 'x') { next SEQ unless $neg->($mode & 0100) }
                     elsif ($c eq 'f') { next SEQ unless $neg->($mode & 0100000)}
                     elsif ($c eq 'd') { next SEQ unless $neg->($mode & 0040000)}
                     else {
                         die "Unknown character in filter: $c (in $seq)";
                     }
                 }
                 $pass = 1; last SEQ;
             }
             $pass;
         };
     } elsif (!$filter && $args{file_regex_filter}) {
         $filter = sub {
             my $name = shift;
             return 1 if -d $name;
             return 0 unless -f _;
             return 1 if $name =~ $args{file_regex_filter};
             0;
         };
     }
 
     Complete::Path::complete_path(
         word => $word,
 
         ci => $ci,
         fuzzy => $fuzzy,
         map_case => $map_case,
         exp_im_path => $exp_im_path,
         dig_leaf => $dig_leaf,
 
         list_func => $list,
         is_dir_func => sub { -d $_[0] },
         filter_func => $filter,
         starting_path => $starting_path,
         result_prefix => $result_prefix,
     );
 }
 
 1;
 
 __END__
 
### Complete/Fish.pm ###
 package Complete::Fish;
 
 our $DATE = '2015-09-09'; 
 our $VERSION = '0.04'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        format_completion
                );
 
 require Complete::Bash;
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'Completion module for fish shell',
 };
 
 $SPEC{parse_cmdline} = {
     v => 1.1,
     summary => 'Parse shell command-line for processing by completion routines',
     description => <<'_',
 
 This function converts COMMAND_LINE (str) given by tcsh to become something like
 COMP_WORDS (array) and COMP_CWORD (int), like what bash supplies to shell
 functions. Currently implemented using `Complete::Bash`'s `parse_cmdline`.
 
 _
     args_as => 'array',
     args => {
         cmdline => {
             summary => 'Command-line, defaults to COMMAND_LINE environment',
             schema => 'str*',
             pos => 0,
         },
     },
     result => {
         schema => ['array*', len=>2],
         description => <<'_',
 
 Return a 2-element array: `[$words, $cword]`. `$words` is array of str,
 equivalent to `COMP_WORDS` provided by bash to shell functions. `$cword` is an
 integer, equivalent to `COMP_CWORD` provided by bash to shell functions. The
 word to be completed is at `$words->[$cword]`.
 
 Note that COMP_LINE includes the command name. If you want the command-line
 arguments only (like in `@ARGV`), you need to strip the first element from
 `$words` and reduce `$cword` by 1.
 
 _
     },
     result_naked => 1,
 };
 sub parse_cmdline {
     my ($line) = @_;
 
     $line //= $ENV{COMMAND_LINE};
     Complete::Bash::parse_cmdline($line, length($line));
 }
 
 $SPEC{format_completion} = {
     v => 1.1,
     summary => 'Format completion for output (for shell)',
     description => <<'_',
 
 fish accepts completion reply in the form of one entry per line to STDOUT.
 Description can be added to each entry, prefixed by tab character.
 
 _
     args_as => 'array',
     args => {
         completion => {
             summary => 'Completion answer structure',
             description => <<'_',
 
 Either an array or hash, as described in `Complete`.
 
 _
             schema=>['any*' => of => ['hash*', 'array*']],
             req=>1,
             pos=>0,
         },
     },
     result => {
         summary => 'Formatted string (or array, if `as` key is set to `array`)',
         schema => ['any*' => of => ['str*', 'array*']],
     },
     result_naked => 1,
 };
 sub format_completion {
     my $comp = shift;
 
     my $as;
     my $entries;
 
     if (ref($comp) eq 'HASH') {
         $as = $comp->{as} // 'string';
         $entries = Complete::Bash::format_completion({%$comp, as=>'array'});
     } else {
         $as = 'string';
         $entries = Complete::Bash::format_completion({
             words=>$comp, as=>'array',
         });
     }
 
     {
         my $compary = ref($comp) eq 'HASH' ? $comp->{words} : $comp;
         for (my $i=0; $i<@$compary; $i++) {
 
             my $desc = (ref($compary->[$i]) eq 'HASH' ?
                             $compary->[$i]{description} : '' ) // '';
             $desc =~ s/\R/ /g;
             $entries->[$i] .= "\t$desc";
         }
     }
 
     if ($as eq 'string') {
         $entries = join("", map{"$_\n"} @$entries);
     }
     $entries;
 }
 
 1;
 
 __END__
 
### Complete/Getopt/Long.pm ###
 package Complete::Getopt::Long;
 
 our $DATE = '2015-09-22'; 
 our $VERSION = '0.37'; 
 
 use 5.010001;
 use strict;
 use warnings;
 use Log::Any::IfLOG '$log';
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        complete_cli_arg
                );
 
 our %SPEC;
 
 sub _default_completion {
     require Complete::Env;
     require Complete::File;
     require Complete::Util;
 
     my %args = @_;
     my $word = $args{word} // '';
 
     my $fres;
     $log->tracef('[comp][compgl] entering default completion routine');
 
     if ($word =~ /\A\$/) {
         $log->tracef('[comp][compgl] completing shell variable');
         {
             my $compres = Complete::Env::complete_env(
                 word=>$word);
             last unless @$compres;
             $fres = {words=>$compres, esc_mode=>'shellvar'};
             goto RETURN_RES;
         }
     }
 
     if ($word =~ m!\A~([^/]*)\z!) {
         $log->tracef("[comp][compgl] completing userdir, user=%s", $1);
         {
             eval { require Unix::Passwd::File };
             last if $@;
             my $res = Unix::Passwd::File::list_users(detail=>1);
             last unless $res->[0] == 200;
             my $compres = Complete::Util::complete_array_elem(
                 array=>[map {"~" . $_->{user} . ((-d $_->{home}) ? "/":"")}
                             @{ $res->[2] }],
                 word=>$word,
             );
             last unless @$compres;
             $fres = {words=>$compres, path_sep=>'/'};
             goto RETURN_RES;
         }
     }
 
     if ($word =~ m!\A(~[^/]*)/!) {
         $log->tracef("[comp][compgl] completing file, path=<%s>", $word);
         $fres = {words=>Complete::File::complete_file(word=>$word),
                  path_sep=>'/'};
         goto RETURN_RES;
     }
 
     require String::Wildcard::Bash;
     if (String::Wildcard::Bash::contains_wildcard($word)) {
         $log->tracef("[comp][compgl] completing with wildcard glob, glob=<%s>", "$word*");
         {
             my $compres = [glob("$word*")];
             last unless @$compres;
             for (@$compres) {
                 $_ .= "/" if (-d $_);
             }
             $fres = {words=>$compres, path_sep=>'/'};
             goto RETURN_RES;
         }
     }
     $log->tracef("[comp][compgl] completing with file, file=<%s>", $word);
     $fres = {words=>Complete::File::complete_file(word=>$word),
              path_sep=>'/'};
   RETURN_RES:
     $log->tracef("[comp][compgl] leaving default completion routine, result=%s", $fres);
     $fres;
 }
 
 sub _expand1 {
     my ($opt, $opts) = @_;
     my @candidates;
     my $is_hash = ref($opts) eq 'HASH';
     for ($is_hash ? (sort {length($a)<=>length($b)} keys %$opts) : @$opts) {
         next unless index($_, $opt) == 0;
         push @candidates, $is_hash ? $opts->{$_} : $_;
         last if $opt eq $_;
     }
     return @candidates == 1 ? $candidates[0] : undef;
 }
 
 sub _mark_seen {
     my ($seen_opts, $opt, $opts) = @_;
     my $opthash = $opts->{$opt};
     return unless $opthash;
     my $ospec = $opthash->{ospec};
     for (keys %$opts) {
         my $v = $opts->{$_};
         $seen_opts->{$_}++ if $v->{ospec} eq $ospec;
     }
 }
 
 $SPEC{complete_cli_arg} = {
     v => 1.1,
     summary => 'Complete command-line argument using '.
         'Getopt::Long specification',
     description => <<'_',
 
 This routine can complete option names, where the option names are retrieved
 from `Getopt::Long` specification. If you provide completion routine in
 `completion`, you can also complete _option values_ and _arguments_.
 
 Note that this routine does not use `Getopt::Long` (it does its own parsing) and
 currently is not affected by Getopt::Long's configuration. Its behavior mimics
 Getopt::Long under these configuration: `no_ignore_case`, `bundling` (or
 `no_bundling` if the `bundling` option is turned off). Which I think is the
 sensible default. This routine also does not currently support `auto_help` and
 `auto_version`, so you'll need to add those options specifically if you want to
 recognize `--help/-?` and `--version`, respectively.
 
 _
     args => {
         getopt_spec => {
             summary => 'Getopt::Long specification',
             schema  => 'hash*',
             req     => 1,
         },
         completion => {
             summary     =>
                 'Completion routine to complete option value/argument',
             schema      => 'code*',
             description => <<'_',
 
 Completion code will receive a hash of arguments (`%args`) containing these
 keys:
 
 * `type` (str, what is being completed, either `optval`, or `arg`)
 * `word` (str, word to be completed)
 * `cword` (int, position of words in the words array, starts from 0)
 * `opt` (str, option name, e.g. `--str`; undef if we're completing argument)
 * `ospec` (str, Getopt::Long option spec, e.g. `str|S=s`; undef when completing
   argument)
 * `argpos` (int, argument position, zero-based; undef if type='optval')
 * `nth` (int, the number of times this option has seen before, starts from 0
   that means this is the first time this option has been seen; undef when
   type='arg')
 * `seen_opts` (hash, all the options seen in `words`)
 * `parsed_opts` (hash, options parsed the standard/raw way)
 
 as well as all keys from `extras` (but these won't override the above keys).
 
 and is expected to return a completion answer structure as described in
 `Complete` which is either a hash or an array. The simplest form of answer is
 just to return an array of strings. The various `complete_*` function like those
 in `Complete::Util` or the other `Complete::*` modules are suitable to use here.
 
 Completion routine can also return undef to express declination, in which case
 the default completion routine will then be consulted. The default routine
 completes from shell environment variables (`$FOO`), Unix usernames (`~foo`),
 and files/directories.
 
 Example:
 
     use Complete::Unix qw(complete_user);
     use Complete::Util qw(complete_array_elem);
     complete_cli_arg(
         getopt_spec => {
             'help|h'   => sub{...},
             'format=s' => \$format,
             'user=s'   => \$user,
         },
         completion  => sub {
             my %args  = @_;
             my $word  = $args{word};
             my $ospec = $args{ospec};
             if ($ospec && $ospec eq 'format=s') {
                 complete_array_elem(array=>[qw/json text xml yaml/], word=>$word);
             } else {
                 complete_user(word=>$word);
             }
         },
     );
 
 _
         },
         words => {
             summary     => 'Command line arguments, like @ARGV',
             description => <<'_',
 
 See function `parse_cmdline` in `Complete::Bash` on how to produce this (if
 you're using bash).
 
 _
             schema      => 'array*',
             req         => 1,
         },
         cword => {
             summary     =>
                 "Index in words of the word we're trying to complete",
             description => <<'_',
 
 See function `parse_cmdline` in `Complete::Bash` on how to produce this (if
 you're using bash).
 
 _
             schema      => 'int*',
             req         => 1,
         },
         extras => {
             summary => 'Add extra arguments to completion routine',
             schema  => 'hash',
             description => <<'_',
 
 The keys from this `extras` hash will be merged into the final `%args` passed to
 completion routines. Note that standard keys like `type`, `word`, and so on as
 described in the function description will not be overwritten by this.
 
 _
         },
         bundling => {
             schema  => 'bool*',
             default => 1,
             'summary.alt.bool.not' => 'Turn off bundling',
             description => <<'_',
 
 If you turn off bundling, completion of short-letter options won't support
 bundling (e.g. `-b<tab>` won't add more single-letter options), but single-dash
 multiletter options can be recognized. Currently only those specified with a
 single dash will be completed. For example if you have `-foo=s` in your option
 specification, `-f<tab>` can complete it.
 
 This can be used to complete old-style programs, e.g. emacs which has options
 like `-nw`, `-nbc` etc (but also have double-dash options like
 `--no-window-system` or `--no-blinking-cursor`).
 
 _
         },
     },
     result_naked => 1,
     result => {
         schema => ['any*' => of => ['hash*', 'array*']],
         description => <<'_',
 
 You can use `format_completion` function in `Complete::Bash` module to format
 the result of this function for bash.
 
 _
     },
 };
 sub complete_cli_arg {
     require Complete::Util;
     require Getopt::Long::Util;
 
     my %args = @_;
 
     my $fname = __PACKAGE__ . "::complete_cli_arg"; 
     my $fres;
 
     $args{words} or die "Please specify words";
     my @words = @{ $args{words} };
     defined(my $cword = $args{cword}) or die "Please specify cword";
     my $gospec = $args{getopt_spec} or die "Please specify getopt_spec";
     my $comp = $args{completion};
     my $extras = $args{extras} // {};
     my $bundling = $args{bundling} // 1;
     my %parsed_opts;
 
     $log->tracef('[comp][compgl] entering %s(), words=%s, cword=%d, word=<%s>',
                  $fname, \@words, $cword, $words[$cword]);
 
     my %opts;
     for my $ospec (keys %$gospec) {
         my $res = Getopt::Long::Util::parse_getopt_long_opt_spec($ospec)
             or die "Can't parse option spec '$ospec'";
         $res->{min_vals} //= $res->{type} ? 1 : 0;
         $res->{max_vals} //= $res->{type} || $res->{opttype} ? 1:0;
         for my $o0 (@{ $res->{opts} }) {
             my @o = $res->{is_neg} && length($o0) > 1 ?
                 ($o0, "no$o0", "no-$o0") : ($o0);
             for my $o (@o) {
                 my $k = length($o)==1 ||
                     (!$bundling && $res->{dash_prefix} eq '-') ?
                         "-$o" : "--$o";
                 $opts{$k} = {
                     name => $k,
                     ospec => $ospec, 
                     parsed => $res,
                 };
             }
         }
     }
     my @optnames = sort keys %opts;
 
     my %seen_opts;
 
     my @expects;
 
     my $i = -1;
     my $argpos = 0;
 
   WORD:
     while (1) {
         last WORD if ++$i >= @words;
         my $word = $words[$i];
 
         if ($word eq '--' && $i != $cword) {
             $expects[$i] = {separator=>1};
             while (1) {
                 $i++;
                 last WORD if $i >= @words;
                 $expects[$i] = {arg=>1, argpos=>$argpos++};
             }
         }
 
         if ($word =~ /\A-/) {
 
           SPLIT_BUNDLED:
             {
                 last unless $bundling;
                 my $shorts = $word;
                 if ($shorts =~ s/\A-([^-])(.*)/$2/) {
                     my $opt = "-$1";
                     my $opthash = $opts{$opt};
                     if (!$opthash || $opthash->{parsed}{max_vals}) {
                         last SPLIT_BUNDLED;
                     }
                     $words[$i] = $word = "-$1";
                     $expects[$i]{prefix} = $word;
                     $expects[$i]{word} = '';
                     $expects[$i]{short_only} = 1;
                     my $len_before_split = @words;
                     my $j = $i+1;
                   SHORTOPT:
                     while ($shorts =~ s/(.)//) {
                         $opt = "-$1";
                         $opthash = $opts{$opt};
                         if (!$opthash || $opthash->{parsed}{max_vals}) {
                             $expects[$i]{do_complete_optname} = 0;
                             if (length $shorts) {
                                 splice @words, $j, 0, $opt, '=', $shorts;
                                 $j += 3;
                             } else {
                                 splice @words, $j, 0, $opt;
                                 $j++;
                             }
                             last SHORTOPT;
                         } else {
                             splice @words, $j, 0, $opt;
                             $j++;
                         }
                     }
                     $cword += @words-$len_before_split if $cword > $i;
                 }
             }
 
           SPLIT_EQUAL:
             {
                 if ($word =~ /\A(--?[^=]+)(=)(.*)/) {
                     splice @words, $i, 1, $1, $2, $3;
                     $word = $1;
                     $cword += 2 if $cword >= $i;
                 }
             }
 
             my $opt = $word;
             my $opthash = _expand1($opt, \%opts);
 
             if ($opthash) {
                 $opt = $opthash->{name};
                 $expects[$i]{optname} = $opt;
                 my $nth = $seen_opts{$opt} // 0;
                 $expects[$i]{nth} = $nth;
                 _mark_seen(\%seen_opts, $opt, \%opts);
 
                 my $min_vals = $opthash->{parsed}{min_vals};
                 my $max_vals = $opthash->{parsed}{max_vals};
 
                 if ($i+1 < @words && $words[$i+1] eq '=') {
                     $i++;
                     $expects[$i] = {separator=>1, optval=>$opt, word=>'', nth=>$nth};
                     if (!$max_vals) { $min_vals = $max_vals = 1 }
                 }
 
                 push @{ $parsed_opts{$opt} }, $words[$i+1];
                 for (1 .. $min_vals) {
                     $i++;
                     last WORD if $i >= @words;
                     $expects[$i]{optval} = $opt;
                     $expects[$i]{nth} = $nth;
                 }
                 for (1 .. $max_vals-$min_vals) {
                     last if $i+$_ >= @words;
                     last if $words[$i+$_] =~ /\A-/; 
                     $expects[$i+$_]{optval} = $opt; 
                     $expects[$i]{nth} = $nth;
                 }
             } else {
                 $opt = undef;
                 $expects[$i]{optname} = $opt;
 
                 if ($i+1 < @words && $words[$i+1] eq '=') {
                     $i++;
                     $expects[$i] = {separator=>1, optval=>undef, word=>''};
                     if ($i+1 < @words) {
                         $i++;
                         $expects[$i]{optval} = $opt;
                     }
                 }
             }
         } else {
             $expects[$i]{optname} = '';
             $expects[$i]{arg} = 1;
             $expects[$i]{argpos} = $argpos++;
         }
     }
 
 
     my $exp = $expects[$cword];
     my $word = $exp->{word} // $words[$cword];
 
     my @answers;
 
     {
         last unless exists $exp->{optname};
         last if defined($exp->{do_complete_optname}) &&
             !$exp->{do_complete_optname};
         my $opt = $exp->{optname};
         my @o;
         for (@optnames) {
             my $repeatable = 0;
             next if $exp->{short_only} && /\A--/;
             if ($seen_opts{$_}) {
                 my $opthash = $opts{$_};
                 my $ospecval = $gospec->{$opthash->{ospec}};
                 my $parsed = $opthash->{parsed};
                 if (ref($ospecval) eq 'ARRAY') {
                     $repeatable = 1;
                 } elsif ($parsed->{desttype} || $parsed->{is_inc}) {
                     $repeatable = 1;
                 }
             }
             next if $seen_opts{$_} && !$repeatable && (
                 (!$opt || $opt ne $_) ||
                     (defined($exp->{prefix}) &&
                          index($exp->{prefix}, substr($opt, 1, 1)) >= 0));
             if (defined $exp->{prefix}) {
                 my $o = $_; $o =~ s/\A-//;
                 push @o, "$exp->{prefix}$o";
             } else {
                 push @o, $_;
             }
         }
         my $compres = Complete::Util::complete_array_elem(
             array => \@o, word => $word);
         $log->tracef('[comp][compgl] adding result from option names, '.
                          'matching options=%s', $compres);
         push @answers, $compres;
         if (!exists($exp->{optval}) && !exists($exp->{arg})) {
             $fres = {words=>$compres, esc_mode=>'option'};
             goto RETURN_RES;
         }
     }
 
     {
         last unless exists($exp->{optval});
         my $opt = $exp->{optval};
         my $opthash = $opts{$opt} if $opt;
         my %compargs = (
             %$extras,
             type=>'optval', words=>\@words, cword=>$args{cword},
             word=>$word, opt=>$opt, ospec=>$opthash->{ospec},
             argpos=>undef, nth=>$exp->{nth}, seen_opts=>\%seen_opts,
             parsed_opts=>\%parsed_opts,
         );
         my $compres;
         if ($comp) {
             $log->tracef("[comp][compgl] invoking routine supplied from 'completion' argument to complete option value, option=<%s>", $opt);
             $compres = $comp->(%compargs);
             $log->tracef('[comp][compgl] adding result from routine: %s', $compres);
         }
         if (!$compres || !$comp) {
             $compres = _default_completion(%compargs);
             $log->tracef('[comp][compgl] adding result from default '.
                              'completion routine');
         }
         push @answers, $compres;
     }
 
     {
         last unless exists($exp->{arg});
         my %compargs = (
             %$extras,
             type=>'arg', words=>\@words, cword=>$args{cword},
             word=>$word, opt=>undef, ospec=>undef,
             argpos=>$exp->{argpos}, seen_opts=>\%seen_opts,
             parsed_opts=>\%parsed_opts,
         );
         $log->tracef('[comp][compgl] invoking \'completion\' routine '.
                          'to complete argument');
         my $compres = $comp->(%compargs);
         if (!defined $compres) {
             $compres = _default_completion(%compargs);
             $log->tracef('[comp][compgl] adding result from default '.
                              'completion routine: %s', $compres);
         }
         push @answers, $compres;
     }
 
     $log->tracef("[comp][compgl] combining result from %d source(s)", ~~@answers);
     $fres = Complete::Util::combine_answers(@answers) // [];
 
   RETURN_RES:
     $log->tracef("[comp][compgl] leaving %s(), result=%s", $fname, $fres);
     $fres;
 }
 
 1;
 
 __END__
 
### Complete/Path.pm ###
 package Complete::Path;
 
 our $DATE = '2015-09-22'; 
 our $VERSION = '0.19'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Complete::Setting;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        complete_path
                );
 
 sub _dig_leaf {
     my ($p, $list_func, $is_dir_func, $path_sep) = @_;
     my $num_dirs;
     my $listres = $list_func->($p, '', 0);
     return $p unless ref($listres) eq 'ARRAY' && @$listres == 1;
     my $e = $listres->[0];
     my $p2 = $p =~ m!\Q$path_sep\E\z! ? "$p$e" : "$p$path_sep$e";
     my $is_dir;
     if ($e =~ m!\Q$path_sep\E\z!) {
         $is_dir++;
     } else {
         $is_dir = $is_dir_func && $is_dir_func->($p2);
     }
     return _dig_leaf($p2, $list_func, $is_dir_func, $path_sep) if $is_dir;
     $p2;
 }
 
 our %SPEC;
 
 $SPEC{complete_path} = {
     v => 1.1,
     summary => 'Complete path',
     description => <<'_',
 
 Complete path, for anything path-like. Meant to be used as backend for other
 functions like `Complete::File::complete_file` or
 `Complete::Module::complete_module`. Provides features like case-insensitive
 matching, expanding intermediate paths, and case mapping.
 
 Algorithm is to split path into path elements, then list items (using the
 supplied `list_func`) and perform filtering (using the supplied `filter_func`)
 at every level.
 
 _
     args => {
         word => {
             schema  => [str=>{default=>''}],
             pos     => 0,
         },
         list_func => {
             summary => 'Function to list the content of intermediate "dirs"',
             schema => 'code*',
             req => 1,
             description => <<'_',
 
 Code will be called with arguments: ($path, $cur_path_elem, $is_intermediate).
 Code should return an arrayref containing list of elements. "Directories" can be
 marked by ending the name with the path separator (see `path_sep`). Or, you can
 also provide an `is_dir_func` function that will be consulted after filtering.
 If an item is a "directory" then its name will be suffixed with a path
 separator by `complete_path()`.
 
 _
         },
         is_dir_func => {
             summary => 'Function to check whether a path is a "dir"',
             schema  => 'code*',
             description => <<'_',
 
 Optional. You can provide this function to determine if an item is a "directory"
 (so its name can be suffixed with path separator). You do not need to do this if
 you already suffix names of "directories" with path separator in `list_func`.
 
 One reason you might want to provide this and not mark "directories" in
 `list_func` is when you want to do extra filtering with `filter_func`. Sometimes
 you do not want to suffix the names first (example: see `complete_file` in
 `Complete::File`).
 
 _
         },
         starting_path => {
             schema => 'str*',
             req => 1,
             default => '',
         },
         filter_func => {
             schema  => 'code*',
             description => <<'_',
 
 Provide extra filtering. Code will be given path and should return 1 if the item
 should be included in the final result or 0 if the item should be excluded.
 
 _
         },
 
         path_sep => {
             schema  => 'str*',
             default => '/',
         },
         ci => {
             summary => 'Case-insensitive matching',
             schema  => 'bool',
         },
         fuzzy => {
             summary => 'Fuzzy matching',
             schema  => ['int*', min=>0],
         },
         map_case => {
             summary => 'Treat _ (underscore) and - (dash) as the same',
             schema  => 'bool',
             description => <<'_',
 
 This is another convenience option like `ci`, where you can type `-` (without
 pressing Shift, at least in US keyboard) and can still complete `_` (underscore,
 which is typed by pressing Shift, at least in US keyboard).
 
 This option mimics similar option in bash/readline: `completion-map-case`.
 
 _
         },
         exp_im_path => {
             summary => 'Expand intermediate paths',
             schema  => 'bool',
             description => <<'_',
 
 This option mimics feature in zsh where when you type something like `cd
 /h/u/b/myscript` and get `cd /home/ujang/bin/myscript` as a completion answer.
 
 _
         },
         dig_leaf => {
             summary => 'Dig leafs',
             schema => 'bool',
             description => <<'_',
 
 This feature mimics what's seen on GitHub. If a directory entry only contains a
 single entry, it will directly show the subentry (and subsubentry and so on) to
 save a number of tab presses.
 
 _
         },
     },
     result_naked => 1,
     result => {
         schema => 'array',
     },
 };
 sub complete_path {
     require Complete::Util;
 
     my %args   = @_;
     my $word   = $args{word} // "";
     my $path_sep = $args{path_sep} // '/';
     my $list_func   = $args{list_func};
     my $is_dir_func = $args{is_dir_func};
     my $filter_func = $args{filter_func};
     my $ci          = $args{ci} // $Complete::Setting::OPT_CI;
     my $fuzzy       = $args{fuzzy} // $Complete::Setting::OPT_FUZZY;
     my $map_case    = $args{map_case} // $Complete::Setting::OPT_MAP_CASE;
     my $exp_im_path = $args{exp_im_path} // $Complete::Setting::OPT_EXP_IM_PATH;
     my $dig_leaf    = $args{dig_leaf} // $Complete::Setting::OPT_DIG_LEAF;
     my $result_prefix = $args{result_prefix};
     my $starting_path = $args{starting_path} // '';
 
     my $re_ends_with_path_sep = qr!\A\z|\Q$path_sep\E\z!;
 
     my @intermediate_dirs;
     {
         @intermediate_dirs = split qr/\Q$path_sep/, $word;
         @intermediate_dirs = ('') if !@intermediate_dirs;
         push @intermediate_dirs, '' if $word =~ $re_ends_with_path_sep;
     }
 
     my $leaf = pop @intermediate_dirs;
     @intermediate_dirs = ('') if !@intermediate_dirs;
 
 
     my @candidate_paths;
 
     for my $i (0..$#intermediate_dirs) {
         my $intdir = $intermediate_dirs[$i];
         my $intdir_with_path_sep = "$intdir$path_sep";
         my @dirs;
         if ($i == 0) {
             @dirs = ($starting_path);
         } else {
             @dirs = @candidate_paths;
         }
 
         if ($i == $#intermediate_dirs && $intdir eq '') {
             @candidate_paths = @dirs;
             last;
         }
 
         my @new_candidate_paths;
         for my $dir (@dirs) {
             my $listres = $list_func->($dir, $intdir, 1);
             next unless $listres && @$listres;
             my $matches = Complete::Util::complete_array_elem(
                 word => $intdir, array => $listres,
                 ci=>$ci, fuzzy=>$fuzzy, map_case=>$map_case,
             );
             my $exact_matches = [grep {
                 length($intdir)+length($path_sep) eq length($_)
             } @$matches];
 
             if ($exp_im_path && @$exact_matches == 1) {
                 $matches = $exact_matches;
             }
 
             for (@$matches) {
                 my $p = $dir =~ $re_ends_with_path_sep ?
                     "$dir$_" : "$dir$path_sep$_";
                 push @new_candidate_paths, $p;
             }
 
         }
         return [] unless @new_candidate_paths;
         @candidate_paths = @new_candidate_paths;
     }
 
     my $cut_chars = 0;
     if (length($starting_path)) {
         $cut_chars += length($starting_path);
         unless ($starting_path =~ /\Q$path_sep\E\z/) {
             $cut_chars += length($path_sep);
         }
     }
 
     my @res;
     for my $dir (@candidate_paths) {
         my $listres = $list_func->($dir, $leaf, 0);
         next unless $listres && @$listres;
         my $matches = Complete::Util::complete_array_elem(
             word => $leaf, array => $listres,
             ci=>$ci, fuzzy=>$fuzzy, map_case=>$map_case,
         );
 
       L1:
         for my $e (@$matches) {
             my $p = $dir =~ $re_ends_with_path_sep ?
                 "$dir$e" : "$dir$path_sep$e";
             {
                 local $_ = $p; 
                 next L1 if $filter_func && !$filter_func->($p);
             }
 
             my $is_dir;
             if ($e =~ $re_ends_with_path_sep) {
                 $is_dir = 1;
             } else {
                 local $_ = $p; 
                 $is_dir = $is_dir_func->($p);
             }
 
             if ($is_dir && $dig_leaf) {
                 $p = _dig_leaf($p, $list_func, $is_dir_func, $path_sep);
                 if ($p =~ $re_ends_with_path_sep) {
                     $is_dir = 1;
                 } else {
                     local $_ = $p; 
                     $is_dir = $is_dir_func->($p);
                 }
             }
 
             my $p0 = $p;
             substr($p, 0, $cut_chars) = '' if $cut_chars;
             $p = "$result_prefix$p" if length($result_prefix);
             unless ($p =~ /\Q$path_sep\E\z/) {
                 $p .= $path_sep if $is_dir;
             }
             push @res, $p;
         }
     }
 
     \@res;
 }
 1;
 
 __END__
 
### Complete/Setting.pm ###
 package Complete::Setting;
 
 our $DATE = '2015-09-16'; 
 our $VERSION = '0.16'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 our $OPT_CI          = ($ENV{COMPLETE_OPT_CI}          // 1) ? 1:0;
 our $OPT_FUZZY       = ($ENV{COMPLETE_OPT_FUZZY}       // 1)+0;
 our $OPT_MAP_CASE    = ($ENV{COMPLETE_OPT_MAP_CASE}    // 1) ? 1:0;
 our $OPT_EXP_IM_PATH = ($ENV{COMPLETE_OPT_EXP_IM_PATH} // 1) ? 1:0;
 our $OPT_DIG_LEAF    = ($ENV{COMPLETE_OPT_DIG_LEAF}    // 1) ? 1:0;
 
 1;
 
 __END__
 
### Complete/Tcsh.pm ###
 package Complete::Tcsh;
 
 our $DATE = '2015-09-09'; 
 our $VERSION = '0.02'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        parse_cmdline
                        format_completion
                );
 
 require Complete::Bash;
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'Completion module for tcsh shell',
 };
 
 $SPEC{parse_cmdline} = {
     v => 1.1,
     summary => 'Parse shell command-line for processing by completion routines',
     description => <<'_',
 
 This function converts COMMAND_LINE (str) given by tcsh to become something like
 COMP_WORDS (array) and COMP_CWORD (int), like what bash supplies to shell
 functions. Currently implemented using `Complete::Bash`'s `parse_cmdline`.
 
 _
     args_as => 'array',
     args => {
         cmdline => {
             summary => 'Command-line, defaults to COMMAND_LINE environment',
             schema => 'str*',
             pos => 0,
         },
     },
     result => {
         schema => ['array*', len=>2],
         description => <<'_',
 
 Return a 2-element array: `[$words, $cword]`. `$words` is array of str,
 equivalent to `COMP_WORDS` provided by bash to shell functions. `$cword` is an
 integer, equivalent to `COMP_CWORD` provided by bash to shell functions. The
 word to be completed is at `$words->[$cword]`.
 
 Note that COMP_LINE includes the command name. If you want the command-line
 arguments only (like in `@ARGV`), you need to strip the first element from
 `$words` and reduce `$cword` by 1.
 
 _
     },
     result_naked => 1,
 };
 sub parse_cmdline {
     my ($line) = @_;
 
     $line //= $ENV{COMMAND_LINE};
     Complete::Bash::parse_cmdline($line, length($line));
 }
 
 $SPEC{format_completion} = {
     v => 1.1,
     summary => 'Format completion for output (for shell)',
     description => <<'_',
 
 tcsh accepts completion reply in the form of one entry per line to STDOUT.
 Currently the formatting is done using `Complete::Bash`'s `format_completion`
 because escaping rule and so on are not yet well defined in tcsh.
 
 _
     args_as => 'array',
     args => {
         completion => {
             summary => 'Completion answer structure',
             description => <<'_',
 
 Either an array or hash, as described in `Complete`.
 
 _
             schema=>['any*' => of => ['hash*', 'array*']],
             req=>1,
             pos=>0,
         },
     },
     result => {
         summary => 'Formatted string (or array, if `as` is set to `array`)',
         schema => ['any*' => of => ['str*', 'array*']],
     },
     result_naked => 1,
 };
 sub format_completion {
     Complete::Bash::format_completion(@_);
 }
 
 1;
 
 __END__
 
### Complete/Util.pm ###
 package Complete::Util;
 
 our $DATE = '2015-09-18'; 
 our $VERSION = '0.38'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Complete::Setting;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        hashify_answer
                        arrayify_answer
                        combine_answers
                        complete_array_elem
                        complete_hash_key
                );
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'General completion routine',
 };
 
 $SPEC{hashify_answer} = {
     v => 1.1,
     summary => 'Make sure we return completion answer in hash form',
     description => <<'_',
 
 This function accepts a hash or an array. If it receives an array, will convert
 the array into `{words=>$ary}' first to make sure the completion answer is in
 hash form.
 
 Then will add keys from `meta` to the hash.
 
 _
     args => {
         arg => {
             summary => '',
             schema  => ['any*' => of => ['array*','hash*']],
             req => 1,
             pos => 0,
         },
         meta => {
             summary => 'Metadata (extra keys) for the hash',
             schema  => 'hash*',
             pos => 1,
         },
     },
     result_naked => 1,
     result => {
         schema => 'hash*',
     },
 };
 sub hashify_answer {
     my $ans = shift;
     if (ref($ans) ne 'HASH') {
         $ans = {words=>$ans};
     }
     if (@_) {
         my $meta = shift;
         for (keys %$meta) {
             $ans->{$_} = $meta->{$_};
         }
     }
     $ans;
 }
 
 $SPEC{arrayify_answer} = {
     v => 1.1,
     summary => 'Make sure we return completion answer in array form',
     description => <<'_',
 
 This is the reverse of `hashify_answer`. It accepts a hash or an array. If it
 receives a hash, will return its `words` key.
 
 _
     args => {
         arg => {
             summary => '',
             schema  => ['any*' => of => ['array*','hash*']],
             req => 1,
             pos => 0,
         },
     },
     result_naked => 1,
     result => {
         schema => 'array*',
     },
 };
 sub arrayify_answer {
     my $ans = shift;
     if (ref($ans) eq 'HASH') {
         $ans = $ans->{words};
     }
     $ans;
 }
 
 sub __min(@) {
     my $m = $_[0];
     for (@_) {
         $m = $_ if $_ < $m;
     }
     $m;
 }
 
 sub __editdist {
     my @a = split //, shift;
     my @b = split //, shift;
 
     my @d;
     $d[$_][0] = $_ for 0 .. @a;
     $d[0][$_] = $_ for 0 .. @b;
 
     for my $i (1 .. @a) {
         for my $j (1 .. @b) {
             $d[$i][$j] = (
                 $a[$i-1] eq $b[$j-1]
                     ? $d[$i-1][$j-1]
                     : 1 + __min(
                         $d[$i-1][$j],
                         $d[$i][$j-1],
                         $d[$i-1][$j-1]
                     )
                 );
         }
     }
 
     $d[@a][@b];
 }
 
 $SPEC{complete_array_elem} = {
     v => 1.1,
     summary => 'Complete from array',
     description => <<'_',
 
 Will sort the resulting completion list, so you don't have to presort the array.
 
 _
     args => {
         word     => { schema=>[str=>{default=>''}], pos=>0, req=>1 },
         array    => { schema=>['array*'=>{of=>'str*'}], req=>1 },
         ci       => { schema=>['bool'] },
         exclude  => { schema=>['array*'] },
         fuzzy    => { schema=>['int*', min=>0] },
         map_case => {
             summary => 'Treat _ (underscore) and - (dash) as the same',
             schema  => ['bool'],
         },
     },
     result_naked => 1,
     result => {
         schema => 'array',
     },
 };
 sub complete_array_elem {
     state $code_editdist = do {
         if (eval { require Text::Levenshtein::XS; 1 }) {
             \&Text::Levenshtein::XS::distance;
         } else {
             \&__editdist;
         }
     };
 
     my %args  = @_;
 
     my $array    = $args{array} or die "Please specify array";
     my $word     = $args{word} // "";
     my $ci       = $args{ci} // $Complete::Setting::OPT_CI;
     my $fuzzy    = $args{fuzzy} // $Complete::Setting::OPT_FUZZY;
     my $map_case = $args{map_case} // $Complete::Setting::OPT_MAP_CASE;
 
     return [] unless @$array;
 
     my $wordn = $ci ? uc($word) : $word; $wordn =~ s/_/-/g if $map_case;
 
     my @words;
     for my $el (@$array) {
         my $eln = $ci ? uc($el) : $el; $eln =~ s/_/-/g if $map_case;
         next unless 0==index($eln, $wordn);
         push @words, $el;
     }
 
     if ($fuzzy && !@words) {
         my $factor = 1.3;
         my $x = -1;
         my $y = 1;
 
         my %editdists;
       ELEM:
         for my $el (@$array) {
             my $eln = $ci ? uc($el) : $el; $eln =~ s/_/-/g if $map_case;
             for my $l (length($wordn)-$y .. length($wordn)+$y) {
                 next if $l <= 0;
                 my $chopped = substr($eln, 0, $l);
                 my $d;
                 unless (defined $editdists{$chopped}) {
                     $d = $code_editdist->($wordn, $chopped);
                     $editdists{$chopped} = $d;
                 } else {
                     $d = $editdists{$chopped};
                 }
                 my $maxd = __min(
                     __min(length($chopped), length($word))/$factor,
                     $fuzzy,
                 );
                 next unless $d <= $maxd;
                 push @words, $el;
                 next ELEM;
             }
         }
     }
 
     if ($args{exclude}) {
         my $exclude = $ci ? [map {uc} @{ $args{exclude} }] : $args{exclude};
         @words = grep {
             my $w = $_;
             !(grep {($ci ? uc($w) : $w) eq $_} @$exclude);
         } @words;
     }
 
     return $ci ? [sort {lc($a) cmp lc($b)} @words] : [sort @words];
 }
 
 $SPEC{complete_hash_key} = {
     v => 1.1,
     summary => 'Complete from hash keys',
     args => {
         word     => { schema=>[str=>{default=>''}], pos=>0, req=>1 },
         hash     => { schema=>['hash*'=>{}], req=>1 },
         ci       => { schema=>['bool'] },
         fuzzy    => { schema=>['int*', min=>0] },
         map_case => { schema=>['bool'] },
     },
     result_naked => 1,
     result => {
         schema => 'array',
     },
 };
 sub complete_hash_key {
     my %args  = @_;
     my $hash     = $args{hash} or die "Please specify hash";
     my $word     = $args{word} // "";
     my $ci       = $args{ci} // $Complete::Setting::OPT_CI;
     my $fuzzy    = $args{fuzzy} // $Complete::Setting::OPT_FUZZY;
     my $map_case = $args{map_case} // $Complete::Setting::OPT_MAP_CASE;
 
     my @array = $ci ?
         (sort {uc($a) cmp uc($b)} keys %$hash) : (sort keys %$hash);
     complete_array_elem(
         word=>$word, array=>\@array,
         ci=>$ci, fuzzy=>$fuzzy, map_case=>$map_case,
     );
 }
 
 $SPEC{combine_answers} = {
     v => 1.1,
     summary => 'Given two or more answers, combine them into one',
     description => <<'_',
 
 This function is useful if you want to provide a completion answer that is
 gathered from multiple sources. For example, say you are providing completion
 for the Perl tool `cpanm`, which accepts a filename (a tarball like `*.tar.gz`),
 a directory, or a module name. You can do something like this:
 
     combine_answers(
         complete_file(word=>$word, ci=>1),
         complete_module(word=>$word, ci=>1),
     );
 
 If a completion answer has a metadata `final` set to true, then that answer is
 used as the final answer without any combining with the other answers.
 
 _
     args => {
         answers => {
             schema => [
                 'array*' => {
                     of => ['any*', of=>['hash*','array*']], 
                     min_len => 1,
                 },
             ],
             req => 1,
             pos => 0,
             greedy => 1,
         },
     },
     args_as => 'array',
     result_naked => 1,
     result => {
         schema => 'hash*',
         description => <<'_',
 
 Return a combined completion answer. Words from each input answer will be
 combined, order preserved and duplicates removed. The other keys from each
 answer will be merged.
 
 _
     },
 };
 sub combine_answers {
     require List::Util;
 
     return undef unless @_;
     return $_[0] if @_ < 2;
 
     my $final = {words=>[]};
     my $encounter_hash;
     my $add_words = sub {
         my $words = shift;
         for my $entry (@$words) {
             push @{ $final->{words} }, $entry
                 unless List::Util::first(
                     sub {
                         (ref($entry) ? $entry->{word} : $entry)
                             eq
                                 (ref($_) ? $_->{word} : $_)
                             }, @{ $final->{words} }
                         );
         }
     };
 
   ANSWER:
     for my $ans (@_) {
         if (ref($ans) eq 'ARRAY') {
             $add_words->($ans);
         } elsif (ref($ans) eq 'HASH') {
             $encounter_hash++;
 
             if ($ans->{final}) {
                 $final = $ans;
                 last ANSWER;
             }
 
             $add_words->($ans->{words} // []);
             for (keys %$ans) {
                 if ($_ eq 'words') {
                     next;
                 } elsif ($_ eq 'static') {
                     if (exists $final->{$_}) {
                         $final->{$_} &&= $ans->{$_};
                     } else {
                         $final->{$_} = $ans->{$_};
                     }
                 } else {
                     $final->{$_} = $ans->{$_};
                 }
             }
         }
     }
 
     if ($final->{words}) {
         $final->{words} = [
             sort {
                 (ref($a) ? $a->{word} : $a) cmp
                     (ref($b) ? $b->{word} : $b);
             }
                 @{ $final->{words} }];
     }
 
     $encounter_hash ? $final : $final->{words};
 }
 
 1;
 
 __END__
 
### Complete/Zsh.pm ###
 package Complete::Zsh;
 
 our $DATE = '2015-09-09'; 
 our $VERSION = '0.02'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        parse_cmdline
                        format_completion
                );
 
 require Complete::Bash;
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'Completion module for zsh shell',
 };
 
 $SPEC{parse_cmdline} = {
     v => 1.1,
     summary => 'Parse shell command-line for processing by completion routines',
     description => <<'_',
 
 This function converts COMP_LINE (str) (which can be supplied by zsh from `read
 -l`) and COMP_POINT (int) (which can be supplied by zsh from `read -ln`) into
 COMP_WORDS (array) and COMP_CWORD (int), like what bash supplies to shell
 functions. Currently implemented using `Complete::Bash`'s `parse_cmdline`.
 
 _
     args_as => 'array',
     args => {
         cmdline => {
             summary => 'Command-line, defaults to COMP_LINE environment',
             schema => 'str*',
             pos => 0,
         },
     },
     result => {
         schema => ['array*', len=>2],
         description => <<'_',
 
 Return a 2-element array: `[$words, $cword]`. `$words` is array of str,
 equivalent to `COMP_WORDS` provided by bash to shell functions. `$cword` is an
 integer, equivalent to `COMP_CWORD` provided by bash to shell functions. The
 word to be completed is at `$words->[$cword]`.
 
 Note that COMP_LINE includes the command name. If you want the command-line
 arguments only (like in `@ARGV`), you need to strip the first element from
 `$words` and reduce `$cword` by 1.
 
 _
     },
     result_naked => 1,
 };
 sub parse_cmdline {
     my ($line) = @_;
 
     $line //= $ENV{COMP_LINE};
     Complete::Bash::parse_cmdline($line, length($line));
 }
 
 $SPEC{format_completion} = {
     v => 1.1,
     summary => 'Format completion for output (for shell)',
     description => <<'_',
 
 zsh accepts completion reply in the form of one entry per line to STDOUT.
 Currently the formatting is done using `Complete::Bash`'s `format_completion`.
 
 _
     args_as => 'array',
     args => {
         completion => {
             summary => 'Completion answer structure',
             description => <<'_',
 
 Either an array or hash, as described in `Complete`.
 
 _
             schema=>['any*' => of => ['hash*', 'array*']],
             req=>1,
             pos=>0,
         },
     },
     result => {
         summary => 'Formatted string (or array, if `as` key is set to `array`)',
         schema => ['any*' => of => ['str*', 'array*']],
     },
     result_naked => 1,
 };
 sub format_completion {
     Complete::Bash::format_completion(@_);
 }
 
 1;
 
 __END__
 
### Config/IOD/Base.pm ###
 package Config::IOD::Base;
 
 our $DATE = '2015-09-08'; 
 our $VERSION = '0.19'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use constant +{
     COL_V_ENCODING => 0, 
     COL_V_WS1 => 1,
     COL_V_VALUE => 2,
     COL_V_WS2 => 3,
     COL_V_COMMENT_CHAR => 4,
     COL_V_COMMENT => 5,
 };
 
 sub new {
     my ($class, %attrs) = @_;
     $attrs{default_section} //= 'GLOBAL';
     $attrs{allow_bang_only} //= 1;
     $attrs{allow_duplicate_key} //= 1;
     $attrs{enable_encoding} //= 1;
     $attrs{enable_quoting}  //= 1;
     $attrs{enable_bracket}  //= 1;
     $attrs{enable_brace}    //= 1;
     $attrs{enable_expr}     //= 0;
     $attrs{ignore_unknown_directive} //= 0;
     bless \%attrs, $class;
 }
 
 sub _parse_command_line {
     my ($self, $str) = @_;
 
     $str =~ s/\A\s+//ms;
     $str =~ s/\s+\z//ms;
 
     my @argv;
     my $buf;
     my $escaped;
     my $double_quoted;
     my $single_quoted;
 
     for my $char (split //, $str) {
         if ($escaped) {
             $buf .= $char;
             $escaped = undef;
             next;
         }
 
         if ($char eq '\\') {
             if ($single_quoted) {
                 $buf .= $char;
             }
             else {
                 $escaped = 1;
             }
             next;
         }
 
         if ($char =~ /\s/) {
             if ($single_quoted || $double_quoted) {
                 $buf .= $char;
             }
             else {
                 push @argv, $buf if defined $buf;
                 undef $buf;
             }
             next;
         }
 
         if ($char eq '"') {
             if ($single_quoted) {
                 $buf .= $char;
                 next;
             }
             $double_quoted = !$double_quoted;
             next;
         }
 
         if ($char eq "'") {
             if ($double_quoted) {
                 $buf .= $char;
                 next;
             }
             $single_quoted = !$single_quoted;
             next;
         }
 
         $buf .= $char;
     }
     push @argv, $buf if defined $buf;
 
     if ($escaped || $single_quoted || $double_quoted) {
         return undef;
     }
 
     \@argv;
 }
 
 sub _parse_raw_value {
     no warnings; 
 
     my ($self, $val, $needs_res) = @_;
 
     if ($val =~ /\A!/ && $self->{enable_encoding}) {
 
         $val =~ s/!(\w+)(\s+)// or return ("Invalid syntax in encoded value");
         my ($enc, $ws1) = ($1, $2);
 
         $enc = "json" if $enc eq 'j';
         $enc = "hex"  if $enc eq 'h';
         $enc = "expr" if $enc eq 'e';
 
         if ($self->{allow_encodings}) {
             return ("Encoding '$enc' is not in ".
                         "allow_encodings list")
                 unless $enc ~~ @{$self->{allow_encodings}};
         }
         if ($self->{disallow_encodings}) {
             return ("Encoding '$enc' is in ".
                         "disallow_encodings list")
                 if $enc ~~ @{$self->{disallow_encodings}};
         }
 
         if ($enc eq 'json') {
             $val =~ /\A
                      (".*"|\[.*\]|\{.*\}|\S+)
                      (\s*)
                      (?: ([;#])(.*) )?
                      \z/x or return ("Invalid syntax in JSON-encoded value");
             my $res = [
                 "!$enc", 
                 $ws1, 
                 $1, 
                 $2, 
                 $3, 
                 $4, 
             ] if $needs_res;
             my $decode_res = $self->_decode_json($val);
             return ($decode_res->[1]) unless $decode_res->[0] == 200;
             return (undef, $res, $decode_res->[2]);
         } elsif ($enc eq 'hex') {
             $val =~ /\A
                      ([0-9A-Fa-f]*)
                      (\s*)
                      (?: ([;#])(.*) )?
                      \z/x or return ("Invalid syntax in hex-encoded value");
             my $res = [
                 "!$enc", 
                 $ws1, 
                 $1, 
                 $2, 
                 $3, 
                 $4, 
             ] if $needs_res;
             my $decode_res = $self->_decode_hex($1);
             return ($decode_res->[1]) unless $decode_res->[0] == 200;
             return (undef, $res, $decode_res->[2]);
         } elsif ($enc eq 'base64') {
             $val =~ m!\A
                       ([A-Za-z0-9+/]*=*)
                       (\s*)
                       (?: ([;#])(.*) )?
                       \z!x or return ("Invalid syntax in base64-encoded value");
             my $res = [
                 "!$enc", 
                 $ws1, 
                 $1, 
                 $2, 
                 $3, 
                 $4, 
             ] if $needs_res;
             my $decode_res = $self->_decode_base64($1);
             return ($decode_res->[1]) unless $decode_res->[0] == 200;
             return (undef, $res, $decode_res->[2]);
         } elsif ($enc eq 'expr') {
             return ("expr is not allowed (enable_expr=0)")
                 unless $self->{enable_expr};
             $val =~ m!\A
                       ((?:[^#;])+?)
                       (\s*)
                       (?: ([;#])(.*) )?
                       \z!x or return ("Invalid syntax in expr-encoded value");
             my $res = [
                 "!$enc", 
                 $ws1, 
                 $1, 
                 $2, 
                 $3, 
                 $4, 
             ] if $needs_res;
             my $decode_res = $self->_decode_expr($1);
             return ($decode_res->[1]) unless $decode_res->[0] == 200;
             return (undef, $res, $decode_res->[2]);
         } else {
             return ("unknown encoding '$enc'");
         }
 
     } elsif ($val =~ /\A"/ && $self->{enable_quoting}) {
 
         $val =~ /\A
                  "( (?:
                          \\\\ | # backslash
                          \\.  | # escaped something
                          [^"\\]+ # non-doublequote or non-backslash
                      )* )"
                  (\s*)
                  (?: ([;#])(.*) )?
                  \z/x or return ("Invalid syntax in quoted string value");
         my $res = [
             '"', 
             '', 
             $1, 
             $2, 
             $3, 
             $4, 
         ] if $needs_res;
         my $decode_res = $self->_decode_json(qq("$1"));
         return ($decode_res->[1]) unless $decode_res->[0] == 200;
         return (undef, $res, $decode_res->[2]);
 
     } elsif ($val =~ /\A\[/ && $self->{enable_bracket}) {
 
         $val =~ /\A
                  \[(.*)\]
                  (?:
                      (\s*)
                      ([#;])(.*)
                  )?
                  \z/x or return ("Invalid syntax in bracketed array value");
         my $res = [
             '[', 
             '', 
             $1, 
             $2, 
             $3, 
             $4, 
         ] if $needs_res;
         my $decode_res = $self->_decode_json("[$1]");
         return ($decode_res->[1]) unless $decode_res->[0] == 200;
         return (undef, $res, $decode_res->[2]);
 
     } elsif ($val =~ /\A\{/ && $self->{enable_brace}) {
 
         $val =~ /\A
                  \{(.*)\}
                  (?:
                      (\s*)
                      ([#;])(.*)
                  )?
                  \z/x or return ("Invalid syntax in braced hash value");
         my $res = [
             '{', 
             '', 
             $1, 
             $2, 
             $3, 
             $4, 
         ] if $needs_res;
         my $decode_res = $self->_decode_json("{$1}");
         return ($decode_res->[1]) unless $decode_res->[0] == 200;
         return (undef, $res, $decode_res->[2]);
 
     } else {
 
         $val =~ /\A
                  (.*?)
                  (\s*)
                  (?: ([#;])(.*) )?
                  \z/x or return ("Invalid syntax in value"); 
         my $res = [
             '', 
             '', 
             $1, 
             $2, 
             $3, 
             $4, 
         ] if $needs_res;
         return (undef, $res, $1);
 
     }
 }
 
 sub _decode_json {
     my ($self, $val) = @_;
     state $json = do {
         require JSON;
         JSON->new->allow_nonref;
     };
     my $res;
     eval { $res = $json->decode($val) };
     if ($@) {
         return [500, "Invalid JSON: $@"];
     } else {
         return [200, "OK", $res];
     }
 }
 
 sub _decode_hex {
     my ($self, $val) = @_;
     [200, "OK", pack("H*", $val)];
 }
 
 sub _decode_base64 {
     my ($self, $val) = @_;
     require MIME::Base64;
     [200, "OK", MIME::Base64::decode_base64($val)];
 }
 
 sub _decode_expr {
     require Config::IOD::Expr;
 
     my ($self, $val) = @_;
     no strict 'refs';
     local *{"Config::IOD::Expr::val"} = sub {
         my $arg = shift;
         if ($arg =~ /(.+)\.(.+)/) {
             return $self->{_res}{$1}{$2};
         } else {
             return $self->{_res}{ $self->{_cur_section} }{$arg};
         }
     };
     Config::IOD::Expr::_parse_expr($val);
 }
 
 sub _err {
     my ($self, $msg) = @_;
     die join(
         "",
         @{ $self->{_include_stack} } ? "$self->{_include_stack}[0] " : "",
         "line $self->{_linum}: ",
         $msg
     );
 }
 
 sub _push_include_stack {
     require Cwd;
 
     my ($self, $path) = @_;
 
     if (@{ $self->{_include_stack} }) {
         require File::Spec;
         my ($vol, $dir, $file) =
             File::Spec->splitpath($self->{_include_stack}[-1]);
         $path = File::Spec->rel2abs($path, File::Spec->catpath($vol, $dir));
     }
 
     my $abs_path = Cwd::abs_path($path) or return [400, "Invalid path name"];
     return [409, "Recursive", $abs_path]
         if grep { $_ eq $abs_path } @{ $self->{_include_stack} };
     push @{ $self->{_include_stack} }, $abs_path;
     return [200, "OK", $abs_path];
 }
 
 sub _pop_include_stack {
     my $self = shift;
 
     die "BUG: Overpopped _pop_include_stack"
         unless @{$self->{_include_stack}};
     pop @{ $self->{_include_stack} };
 }
 
 sub _init_read {
     my $self = shift;
 
     $self->{_include_stack} = [];
 }
 
 sub _read_file {
     my ($self, $filename) = @_;
     open my $fh, "<", $filename
         or die "Can't open file '$filename': $!";
     binmode($fh, ":utf8");
     local $/;
     return ~~<$fh>;
 }
 
 sub read_file {
     my ($self, $filename) = @_;
     $self->_init_read;
     my $res = $self->_push_include_stack($filename);
     die "Can't read '$filename': $res->[1]" unless $res->[0] == 200;
     $res =
         $self->_read_string($self->_read_file($filename));
     $self->_pop_include_stack;
     $res;
 }
 
 sub read_string {
     my ($self, $str) = @_;
     $self->_init_read;
     $self->_read_string($str);
 }
 
 1;
 
 __END__
 
### Config/IOD/Expr.pm ###
 package Config::IOD::Expr;
 
 our $DATE = '2015-09-08'; 
 our $VERSION = '0.19'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 my $EXPR_RE = qr{
 
 (?&ANSWER)
 
 (?(DEFINE)
 
 (?<ANSWER>    (?&ADD))
 (?<ADD>       (?&MULT)   | (?&MULT)  (?: \s* ([+.-]) \s* (?&MULT)  )+)
 (?<MULT>      (?&UNARY)  | (?&UNARY) (?: \s* ([*/x%]) \s* (?&UNARY))+)
 (?<UNARY>     (?&POWER)  | [!~+-] (?&POWER))
 (?<POWER>     (?&TERM)   | (?&TERM) (?: \s* \*\* \s* (?&TERM))+)
 
 (?<TERM>
     (?&NUM)
   | (?&STR_SINGLE)
   | (?&STR_DOUBLE)
   | undef
   | (?&FUNC)
   | \( \s* ((?&ANSWER)) \s* \)
 )
 
 (?<FUNC> val \s* \( (?&TERM) \))
 
 (?<NUM>
     (
      -?
      (?: 0 | [1-9]\d* )
      (?: \. \d+ )?
      (?: [eE] [-+]? \d+ )?
     )
 )
 
 (?<STR_SINGLE>
     (
      '
      (?:
          [^\\']+
        |
          \\ ['\\]
        |
          \\
      )*
      '
     )
 )
 
 (?<STR_DOUBLE>
     (
      "
      (?:
          [^\\"]+
        |
          \\ ["'\\\$tnrfbae]
 # octal, hex, wide hex
      )*
      "
     )
 )
 
 ) # DEFINE
 
 }msx;
 
 sub _parse_expr {
     my $str = shift;
 
     return [400, 'Not a valid expr'] unless $str =~ m{\A$EXPR_RE\z}o;
     my $res = eval $str;
     return [500, "Died when evaluating expr: $@"] if $@;
     [200, "OK", $res];
 }
 
 1;
 
 __END__
 
### Config/IOD/Reader.pm ###
 package Config::IOD::Reader;
 
 our $DATE = '2015-09-08'; 
 our $VERSION = '0.19'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use parent qw(Config::IOD::Base);
 
 sub _merge {
     my ($self, $section) = @_;
 
     my $res = $self->{_res};
     for my $msect (@{ $self->{_merge} }) {
         if ($msect eq $section) {
             next;
         }
         if (!exists($res->{$msect})) {
             local $self->{_linum} = $self->{_linum}-1;
             $self->_err("Can't merge section '$msect' to '$section': ".
                             "Section '$msect' not seen yet");
         }
         for my $k (keys %{ $res->{$msect} }) {
             $res->{$section}{$k} //= $res->{$msect}{$k};
         }
     }
 }
 
 sub _init_read {
     my $self = shift;
 
     $self->SUPER::_init_read;
     $self->{_res} = {};
     $self->{_merge} = undef;
     $self->{_num_seen_section_lines} = 0;
     $self->{_cur_section} = $self->{default_section};
     $self->{_arrayified} = {};
 }
 
 sub _read_string {
     my ($self, $str) = @_;
 
     my $res = $self->{_res};
     my $cur_section = $self->{_cur_section};
 
     my $directive_re = $self->{allow_bang_only} ?
         qr/^;?\s*!\s*(\w+)\s*/ :
         qr/^;\s*!\s*(\w+)\s*/;
 
     my @lines = split /^/, $str;
     local $self->{_linum} = 0;
   LINE:
     for my $line (@lines) {
         $self->{_linum}++;
 
         if ($line !~ /\S/) {
             next LINE;
         }
 
         if ($line =~ s/$directive_re//) {
             my $directive = $1;
             if ($self->{allow_directives}) {
                 $self->_err("Directive '$directive' is not in ".
                                 "allow_directives list")
                     unless grep { $_ eq $directive }
                         @{$self->{allow_directives}};
             }
             if ($self->{disallow_directives}) {
                 $self->_err("Directive '$directive' is in ".
                                 "disallow_directives list")
                     if grep { $_ eq $directive }
                         @{$self->{disallow_directives}};
             }
             my $args = $self->_parse_command_line($line);
             if (!defined($args)) {
                 $self->_err("Invalid arguments syntax '$line'");
             }
             if ($directive eq 'include') {
                 my $path;
                 if (! @$args) {
                     $self->_err("Missing filename to include");
                 } elsif (@$args > 1) {
                     $self->_err("Extraneous arguments");
                 } else {
                     $path = $args->[0];
                 }
                 my $res = $self->_push_include_stack($path);
                 if ($res->[0] != 200) {
                     $self->_err("Can't include '$path': $res->[1]");
                 }
                 $path = $res->[2];
                 $self->_read_string($self->_read_file($path));
                 $self->_pop_include_stack;
             } elsif ($directive eq 'merge') {
                 $self->{_merge} = @$args ? $args : undef;
             } elsif ($directive eq 'noop') {
             } else {
                 if ($self->{ignore_unknown_directive}) {
                     next LINE;
                 } else {
                     $self->_err("Unknown directive '$directive'");
                 }
             }
             next LINE;
         }
 
         if ($line =~ /^\s*[;#]/) {
             next LINE;
         }
 
         if ($line =~ /^\s*\[\s*(.+?)\s*\](?: \s*[;#].*)?/) {
             my $prev_section = $self->{_cur_section};
             $self->{_cur_section} = $cur_section = $1;
             $res->{$cur_section} //= {};
             $self->{_num_seen_section_lines}++;
 
             if ($self->{_merge} && $self->{_num_seen_section_lines} > 1) {
                 $self->_merge($prev_section);
             }
 
             next LINE;
         }
 
         if ($line =~ /^\s*([^=]+?)\s*=\s*(.*)/) {
             my $key = $1;
             my $val = $2;
 
             if ($val =~ /\A["!\\[\{]/) {
                 my ($err, $parse_res, $decoded_val) = $self->_parse_raw_value($val);
                 $self->_err("Invalid value: " . $err) if $err;
                 $val = $decoded_val;
             } else {
                 $val =~ s/\s*[#;].*//; 
             }
 
             if (exists $res->{$cur_section}{$key}) {
                 if (!$self->{allow_duplicate_key}) {
                     $self->_err("Duplicate key: $key (section $cur_section)");
                 } elsif ($self->{_arrayified}{$cur_section}{$key}++) {
                     push @{ $res->{$cur_section}{$key} }, $val;
                 } else {
                     $res->{$cur_section}{$key} = [
                         $res->{$cur_section}{$key}, $val];
                 }
             } else {
                 $res->{$cur_section}{$key} = $val;
             }
 
             next LINE;
         }
 
         $self->_err("Invalid syntax");
     }
 
     if ($self->{_merge} && $self->{_num_seen_section_lines} > 1) {
         $self->_merge($cur_section);
     }
 
     $res;
 }
 
 1;
 
 __END__
 
### Data/Check/Structure.pm ###
 package Data::Check::Structure;
 
 our $DATE = '2014-07-14'; 
 our $VERSION = '0.03'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        is_aoa
                        is_aoaos
                        is_aoh
                        is_aohos
                        is_aos
                        is_hoa
                        is_hoaos
                        is_hoh
                        is_hohos
                        is_hos
                );
 
 sub is_aos {
     my ($data, $opts) = @_;
     $opts //= {};
     my $max = $opts->{max};
 
     return 0 unless ref($data) eq 'ARRAY';
     for my $i (0..@$data-1) {
         last if defined($max) && $i >= $max;
         return 0 if ref($data->[$i]);
     }
     1;
 }
 
 sub is_aoa {
     my ($data, $opts) = @_;
     $opts //= {};
     my $max = $opts->{max};
 
     return 0 unless ref($data) eq 'ARRAY';
     for my $i (0..@$data-1) {
         last if defined($max) && $i >= $max;
         return 0 unless ref($data->[$i]) eq 'ARRAY';
     }
     1;
 }
 
 sub is_aoaos {
     my ($data, $opts) = @_;
     $opts //= {};
     my $max = $opts->{max};
 
     return 0 unless ref($data) eq 'ARRAY';
     my $aos_opts = {max=>$max};
     for my $i (0..@$data-1) {
         last if defined($max) && $i >= $max;
         return 0 unless is_aos($data->[$i], $aos_opts);
     }
     1;
 }
 
 sub is_aoh {
     my ($data, $opts) = @_;
     $opts //= {};
     my $max = $opts->{max};
 
     return 0 unless ref($data) eq 'ARRAY';
     for my $i (0..@$data-1) {
         last if defined($max) && $i >= $max;
         return 0 unless ref($data->[$i]) eq 'HASH';
     }
     1;
 }
 
 sub is_aohos {
     my ($data, $opts) = @_;
     $opts //= {};
     my $max = $opts->{max};
 
     return 0 unless ref($data) eq 'ARRAY';
     my $hos_opts = {max=>$max};
     for my $i (0..@$data-1) {
         last if defined($max) && $i >= $max;
         return 0 unless is_hos($data->[$i], $hos_opts);
     }
     1;
 }
 
 sub is_hos {
     my ($data, $opts) = @_;
     $opts //= {};
     my $max = $opts->{max};
 
     return 0 unless ref($data) eq 'HASH';
     my $i = 0;
     for my $k (keys %$data) {
         last if defined($max) && ++$i >= $max;
         return 0 if ref($data->{$k});
     }
     1;
 }
 
 sub is_hoa {
     my ($data, $opts) = @_;
     $opts //= {};
     my $max = $opts->{max};
 
     return 0 unless ref($data) eq 'HASH';
     my $i = 0;
     for my $k (keys %$data) {
         last if defined($max) && ++$i >= $max;
         return 0 unless ref($data->{$k}) eq 'ARRAY';
     }
     1;
 }
 
 sub is_hoaos {
     my ($data, $opts) = @_;
     $opts //= {};
     my $max = $opts->{max};
 
     return 0 unless ref($data) eq 'HASH';
     my $i = 0;
     for my $k (keys %$data) {
         last if defined($max) && ++$i >= $max;
         return 0 unless is_aos($data->{$k});
     }
     1;
 }
 
 sub is_hoh {
     my ($data, $opts) = @_;
     $opts //= {};
     my $max = $opts->{max};
 
     return 0 unless ref($data) eq 'HASH';
     my $i = 0;
     for my $k (keys %$data) {
         last if defined($max) && ++$i >= $max;
         return 0 unless ref($data->{$k}) eq 'HASH';
     }
     1;
 }
 
 sub is_hohos {
     my ($data, $opts) = @_;
     $opts //= {};
     my $max = $opts->{max};
 
     return 0 unless ref($data) eq 'HASH';
     my $i = 0;
     for my $k (keys %$data) {
         last if defined($max) && ++$i >= $max;
         return 0 unless is_hos($data->{$k});
     }
     1;
 }
 
 1;
 
 __END__
 
### Data/Clean/Base.pm ###
 package Data::Clean::Base;
 
 our $DATE = '2015-06-10'; 
 our $VERSION = '0.28'; 
 
 use 5.010;
 use strict;
 use warnings;
 use Log::Any::IfLOG '$log';
 
 use Function::Fallback::CoreOrPP qw(clone);
 use Scalar::Util qw();
 
 sub new {
     my ($class, %opts) = @_;
     my $self = bless {opts=>\%opts}, $class;
     $log->tracef("Cleanser options: %s", \%opts);
     $self->_generate_cleanser_code;
     $self;
 }
 
 sub command_call_method {
     my ($self, $args) = @_;
     my $mn = $args->[0];
     die "Invalid method name syntax" unless $mn =~ /\A\w+\z/;
     return "{{var}} = {{var}}->$mn; \$ref = ref({{var}})";
 }
 
 sub command_call_func {
     my ($self, $args) = @_;
     my $fn = $args->[0];
     die "Invalid func name syntax" unless $fn =~ /\A\w+(::\w+)*\z/;
     return "{{var}} = $fn({{var}}); \$ref = ref({{var}})";
 }
 
 sub command_one_or_zero {
     my ($self, $args) = @_;
     return "{{var}} = {{var}} ? 1:0; \$ref = ''";
 }
 
 sub command_deref_scalar {
     my ($self, $args) = @_;
     return '{{var}} = ${ {{var}} }; $ref = ref({{var}})';
 }
 
 sub command_stringify {
     my ($self, $args) = @_;
     return '{{var}} = "{{var}}"';
 }
 
 sub command_replace_with_ref {
     my ($self, $args) = @_;
     return '{{var}} = $ref; $ref = ""';
 }
 
 sub command_replace_with_str {
     require String::PerlQuote;
 
     my ($self, $args) = @_;
     return "{{var}} = ".String::PerlQuote::double_quote($args->[0]).'; $ref=""';
 }
 
 sub command_unbless {
     my ($self, $args) = @_;
 
 
     my $acme_damn_available = eval { require Acme::Damn; 1 } ? 1:0;
     return join(
         "",
         "if (!\$Data::Clean::Base::_clone && $acme_damn_available) { ",
         "{{var}} = Acme::Damn::damn({{var}}) ",
         "} else { ",
         "{{var}} = Function::Fallback::CoreOrPP::_unbless_fallback({{var}}) } ",
         "\$ref = ref({{var}})",
     );
 }
 
 sub command_clone {
     my $clone_func;
     eval { require Data::Clone };
     if ($@) {
         require Clone::PP;
         $clone_func = "Clone::PP::clone";
     } else {
         $clone_func = "Data::Clone::clone";
     }
 
     my ($self, $args) = @_;
     my $limit = $args->[0] // 1;
     return join(
         "",
         "if (++\$ctr_circ <= $limit) { ",
         "{{var}} = $clone_func({{var}}); redo ",
         "} else { ",
         "{{var}} = 'CIRCULAR' } ",
         "\$ref = ref({{var}})",
     );
 }
 
 sub command_die {
     my ($self, $args) = @_;
     return "die";
 }
 
 sub _generate_cleanser_code {
     my $self = shift;
     my $opts = $self->{opts};
 
     my (@code, @stmts_ary, @stmts_hash, @stmts_main);
 
     my $n = 0;
     my $add_stmt = sub {
         my $which = shift;
         if ($which eq 'if' || $which eq 'new_if') {
             my ($cond0, $act0) = @_;
             for ([\@stmts_ary, '$e', 'ary'],
                  [\@stmts_hash, '$h->{$k}', 'hash'],
                  [\@stmts_main, '$_', 'main']) {
                 my $act  = $act0 ; $act  =~ s/\Q{{var}}\E/$_->[1]/g;
                 my $cond = $cond0; $cond =~ s/\Q{{var}}\E/$_->[1]/g;
                 push @{ $_->[0] }, "    ".($n && $which ne 'new_if' ? "els":"")."if ($cond) { $act }\n";
             }
             $n++;
         } else {
             my ($stmt0) = @_;
             for ([\@stmts_ary, '$e', 'ary'],
                  [\@stmts_hash, '$h->{$k}', 'hash'],
                  [\@stmts_main, '$_', 'main']) {
                 my $stmt = $stmt0; $stmt =~ s/\Q{{var}}\E/$_->[1]/g;
                 push @{ $_->[0] }, "    $stmt;\n";
             }
         }
     };
     my $add_if = sub {
         $add_stmt->('if', @_);
     };
     my $add_new_if = sub {
         $add_stmt->('new_if', @_);
     };
     my $add_if_ref = sub {
         my ($ref, $act0) = @_;
         $add_if->("\$ref eq '$ref'", $act0);
     };
     my $add_new_if_ref = sub {
         my ($ref, $act0) = @_;
         $add_new_if->("\$ref eq '$ref'", $act0);
     };
 
     for my $on (grep {/\A\w*(::\w+)*\z/} sort keys %$opts) {
         my $o = $opts->{$on};
         next unless $o;
         my $meth = "command_$o->[0]";
         die "Can't handle command $o->[0] for option '$on'" unless $self->can($meth);
         my @args = @$o; shift @args;
         my $act = $self->$meth(\@args);
         $add_if_ref->($on, $act);
     }
 
     for my $p ([-obj => 'Scalar::Util::blessed({{var}})']) {
         my $o = $opts->{$p->[0]};
         next unless $o;
         my $meth = "command_$o->[0]";
         die "Can't handle command $o->[0] for option '$p->[0]'" unless $self->can($meth);
         my @args = @$o; shift @args;
         $add_if->($p->[1], $self->$meth(\@args));
     }
 
     my $circ = $opts->{-circular};
     if ($circ) {
         my $meth = "command_$circ->[0]";
         die "Can't handle command $circ->[0] for option '-circular'" unless $self->can($meth);
         my @args = @$circ; shift @args;
         my $act = $self->$meth(\@args);
         $add_new_if->('$ref && $refs{ {{var}} }++', $act);
     }
 
     $add_new_if_ref->("ARRAY", '$process_array->({{var}})');
     $add_if_ref->("HASH" , '$process_hash->({{var}})');
 
     for my $p ([-ref => '$ref']) {
         my $o = $opts->{$p->[0]};
         next unless $o;
         my $meth = "command_$o->[0]";
         die "Can't handle command $o->[0] for option '$p->[0]'" unless $self->can($meth);
         my @args = @$o; shift @args;
         $add_if->($p->[1], $self->$meth(\@args));
     }
 
     push @code, 'sub {'."\n";
     push @code, 'my $data = shift;'."\n";
     push @code, 'state %refs;'."\n" if $circ;
     push @code, 'state $ctr_circ;'."\n" if $circ;
     push @code, 'state $process_array;'."\n";
     push @code, 'state $process_hash;'."\n";
     push @code, 'if (!$process_array) { $process_array = sub { my $a = shift; for my $e (@$a) { my $ref=ref($e);'."\n".join("", @stmts_ary).'} } }'."\n";
     push @code, 'if (!$process_hash) { $process_hash = sub { my $h = shift; for my $k (keys %$h) { my $ref=ref($h->{$k});'."\n".join("", @stmts_hash).'} } }'."\n";
     push @code, '%refs = (); $ctr_circ=0;'."\n" if $circ;
     push @code, 'for ($data) { my $ref=ref($_);'."\n".join("", @stmts_main).'}'."\n";
     push @code, '$data'."\n";
     push @code, '}'."\n";
 
     my $code = join("", @code).";";
 
     if ($ENV{LOG_CLEANSER_CODE} && $log->is_trace) {
         require String::LineNumber;
         $log->tracef("Cleanser code:\n%s",
                      $ENV{LINENUM} // 1 ?
                          String::LineNumber::linenum($code) : $code);
     }
     eval "\$self->{code} = $code";
     die "Can't generate code: $@" if $@;
     $self->{src} = $code;
 }
 
 sub clean_in_place {
     my ($self, $data) = @_;
 
     $self->{code}->($data);
 }
 
 sub clone_and_clean {
     my ($self, $data) = @_;
     my $clone = clone($data);
     local $Data::Clean::Base::_clone = 1;
     $self->clean_in_place($clone);
 }
 
 1;
 
 __END__
 
### Data/Clean/FromJSON.pm ###
 package Data::Clean::FromJSON;
 
 our $DATE = '2015-06-10'; 
 our $VERSION = '0.28'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use parent qw(Data::Clean::Base);
 
 sub new {
     my ($class, %opts) = @_;
     $opts{"JSON::XS::Boolean"} //= ['one_or_zero'];
     $opts{"JSON::PP::Boolean"} //= ['one_or_zero'];
     $class->SUPER::new(%opts);
 }
 
 sub get_cleanser {
     my $class = shift;
     state $singleton = $class->new;
     $singleton;
 }
 
 1;
 
 __END__
 
### Data/Clean/JSON.pm ###
 package Data::Clean::JSON;
 
 our $DATE = '2015-06-10'; 
 our $VERSION = '0.28'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use parent qw(Data::Clean::Base);
 
 sub new {
     my ($class, %opts) = @_;
     $opts{DateTime}  //= [call_method => 'epoch'];
     $opts{'Time::Moment'} //= [call_method => 'epoch'];
     $opts{Regexp}    //= ['stringify'];
     $opts{SCALAR}    //= ['deref_scalar'];
     $opts{-ref}      //= ['replace_with_ref'];
     $opts{-circular} //= ['clone'];
     $opts{-obj}      //= ['unbless'];
     $class->SUPER::new(%opts);
 }
 
 sub get_cleanser {
     my $class = shift;
     state $singleton = $class->new;
     $singleton;
 }
 
 1;
 
 __END__
 
### Data/Dmp.pm ###
 package Data::Dmp;
 
 our $DATE = '2015-09-27'; 
 our $VERSION = '0.13'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Scalar::Util qw(looks_like_number blessed reftype refaddr);
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT = qw(dd dmp);
 
 our %_seen_refaddrs;
 our %_subscripts;
 our @_fixups;
 
 our $OPT_PERL_VERSION = "5.010";
 
 my %esc = (
     "\a" => "\\a",
     "\b" => "\\b",
     "\t" => "\\t",
     "\n" => "\\n",
     "\f" => "\\f",
     "\r" => "\\r",
     "\e" => "\\e",
 );
 
 sub _double_quote {
     local($_) = $_[0];
 
     s/([\\\"\@\$])/\\$1/g;
     return qq("$_") unless /[^\040-\176]/;  
 
     s/([\a\b\t\n\f\r\e])/$esc{$1}/g;
 
     s/([\0-\037])(?!\d)/sprintf('\\%o',ord($1))/eg;
 
     s/([\0-\037\177-\377])/sprintf('\\x%02X',ord($1))/eg;
     s/([^\040-\176])/sprintf('\\x{%X}',ord($1))/eg;
 
     return qq("$_");
 }
 
 sub _dump {
     my ($val, $subscript) = @_;
 
     my $ref = ref($val);
     if ($ref eq '') {
         if (!defined($val)) {
             return "undef";
         } elsif (looks_like_number($val)) {
             return $val;
         } else {
             return _double_quote($val);
         }
     }
     my $refaddr = refaddr($val);
     $_subscripts{$refaddr} //= $subscript;
     if ($_seen_refaddrs{$refaddr}++) {
         push @_fixups, "\$a->$subscript=\$a",
             ($_subscripts{$refaddr} ? "->$_subscripts{$refaddr}" : ""), ";";
         return "'fix'";
     }
 
     my $class;
 
     if ($ref eq 'Regexp' || $ref eq 'REGEXP') {
         require Regexp::Stringify;
         return Regexp::Stringify::stringify_regexp(
             regexp=>$val, with_qr=>1, plver=>$OPT_PERL_VERSION);
     }
 
     if (blessed $val) {
         $class = $ref;
         $ref = reftype($val);
     }
 
     my $res;
     if ($ref eq 'ARRAY') {
         $res = "[";
         my $i = 0;
         for (@$val) {
             $res .= "," if $i;
             $res .= _dump($_, "$subscript\[$i]");
             $i++;
         }
         $res .= "]";
     } elsif ($ref eq 'HASH') {
         $res = "{";
         my $i = 0;
         for (sort keys %$val) {
             $res .= "," if $i++;
             my $k = /\W/ ? _double_quote($_) : $_;
             my $v = _dump($val->{$_}, "$subscript\{$k}");
             $res .= "$k=>$v";
         }
         $res .= "}";
     } elsif ($ref eq 'SCALAR') {
         $res = "\\"._dump($$val, $subscript);
     } elsif ($ref eq 'REF') {
         $res = "\\"._dump($$val, $subscript);
     } elsif ($ref eq 'CODE') {
         require Data::Dumper;
         local $Data::Dumper::Terse = 1;
         local $Data::Dumper::Indent = 0;
         local $Data::Dumper::Deparse = 1;
         $res = Data::Dumper::Dumper($val);
         if ($OPT_PERL_VERSION < 5.016) {
             $res =~ s/no feature ':all';/no feature;/m;
         }
     } else {
         die "Sorry, I can't dump $val (ref=$ref) yet";
     }
 
     $res = "bless($res,"._double_quote($class).")" if defined($class);
     $res;
 }
 
 our $_is_dd;
 sub _dd_or_dmp {
     local %_seen_refaddrs;
     local %_subscripts;
     local @_fixups;
 
     my $res;
     if (@_ > 1) {
         $res = "(" . join(",", map {_dump($_, '')} @_) . ")";
     } else {
         $res = _dump($_[0], '');
     }
     if (@_fixups) {
         $res = "do{my\$a=$res;" . join("", @_fixups) . "\$a}";
     }
 
     if ($_is_dd) {
         say $res;
         return @_;
     } else {
         return $res;
     }
 }
 
 sub dd { local $_is_dd=1; _dd_or_dmp(@_) } 
 sub dmp { goto &_dd_or_dmp }
 
 1;
 
 __END__
 
### Data/Dump.pm ###
 package Data::Dump;
 
 use strict;
 use vars qw(@EXPORT @EXPORT_OK $VERSION $DEBUG);
 use subs qq(dump);
 
 require Exporter;
 *import = \&Exporter::import;
 @EXPORT = qw(dd ddx);
 @EXPORT_OK = qw(dump pp dumpf quote);
 
 $VERSION = "1.23";
 $DEBUG = 0;
 
 use overload ();
 use vars qw(%seen %refcnt @dump @fixup %require $TRY_BASE64 @FILTERS $INDENT);
 
 $TRY_BASE64 = 50 unless defined $TRY_BASE64;
 $INDENT = "  " unless defined $INDENT;
 
 sub dump
 {
     local %seen;
     local %refcnt;
     local %require;
     local @fixup;
 
     require Data::Dump::FilterContext if @FILTERS;
 
     my $name = "a";
     my @dump;
 
     for my $v (@_) {
 	my $val = _dump($v, $name, [], tied($v));
 	push(@dump, [$name, $val]);
     } continue {
 	$name++;
     }
 
     my $out = "";
     if (%require) {
 	for (sort keys %require) {
 	    $out .= "require $_;\n";
 	}
     }
     if (%refcnt) {
 	for (@dump) {
 	    my $name = $_->[0];
 	    if ($refcnt{$name}) {
 		$out .= "my \$$name = $_->[1];\n";
 		undef $_->[1];
 	    }
 	}
 	for (@fixup) {
 	    $out .= "$_;\n";
 	}
     }
 
     my $paren = (@dump != 1);
     $out .= "(" if $paren;
     $out .= format_list($paren, undef,
 			map {defined($_->[1]) ? $_->[1] : "\$".$_->[0]}
 			    @dump
 		       );
     $out .= ")" if $paren;
 
     if (%refcnt || %require) {
 	$out .= ";\n";
 	$out =~ s/^/$INDENT/gm;
 	$out = "do {\n$out}";
     }
 
     print STDERR "$out\n" unless defined wantarray;
     $out;
 }
 
 *pp = \&dump;
 
 sub dd {
     print dump(@_), "\n";
 }
 
 sub ddx {
     my(undef, $file, $line) = caller;
     $file =~ s,.*[\\/],,;
     my $out = "$file:$line: " . dump(@_) . "\n";
     $out =~ s/^/# /gm;
     print $out;
 }
 
 sub dumpf {
     require Data::Dump::Filtered;
     goto &Data::Dump::Filtered::dump_filtered;
 }
 
 sub _dump
 {
     my $ref  = ref $_[0];
     my $rval = $ref ? $_[0] : \$_[0];
     shift;
 
     my($name, $idx, $dont_remember, $pclass, $pidx) = @_;
 
     my($class, $type, $id);
     my $strval = overload::StrVal($rval);
     if ((my $i = rindex($strval, "=")) >= 0) {
 	$class = substr($strval, 0, $i);
 	$strval = substr($strval, $i+1);
     }
     if ((my $i = index($strval, "(0x")) >= 0) {
 	$type = substr($strval, 0, $i);
 	$id = substr($strval, $i + 2, -1);
     }
     else {
 	die "Can't parse " . overload::StrVal($rval);
     }
     if ($] < 5.008 && $type eq "SCALAR") {
 	$type = "REF" if $ref eq "REF";
     }
     warn "\$$name(@$idx) $class $type $id ($ref)" if $DEBUG;
 
     my $out;
     my $comment;
     my $hide_keys;
     if (@FILTERS) {
 	my $pself = "";
 	$pself = fullname("self", [@$idx[$pidx..(@$idx - 1)]]) if $pclass;
 	my $ctx = Data::Dump::FilterContext->new($rval, $class, $type, $ref, $pclass, $pidx, $idx);
 	my @bless;
 	for my $filter (@FILTERS) {
 	    if (my $f = $filter->($ctx, $rval)) {
 		if (my $v = $f->{object}) {
 		    local @FILTERS;
 		    $out = _dump($v, $name, $idx, 1);
 		    $dont_remember++;
 		}
 		if (defined(my $c = $f->{bless})) {
 		    push(@bless, $c);
 		}
 		if (my $c = $f->{comment}) {
 		    $comment = $c;
 		}
 		if (defined(my $c = $f->{dump})) {
 		    $out = $c;
 		    $dont_remember++;
 		}
 		if (my $h = $f->{hide_keys}) {
 		    if (ref($h) eq "ARRAY") {
 			$hide_keys = sub {
 			    for my $k (@$h) {
 				return 1 if $k eq $_[0];
 			    }
 			    return 0;
 			};
 		    }
 		}
 	    }
 	}
 	push(@bless, "") if defined($out) && !@bless;
 	if (@bless) {
 	    $class = shift(@bless);
 	    warn "More than one filter callback tried to bless object" if @bless;
 	}
     }
 
     unless ($dont_remember) {
 	if (my $s = $seen{$id}) {
 	    my($sname, $sidx) = @$s;
 	    $refcnt{$sname}++;
 	    my $sref = fullname($sname, $sidx,
 				($ref && $type eq "SCALAR"));
 	    warn "SEEN: [\$$name(@$idx)] => [\$$sname(@$sidx)] ($ref,$sref)" if $DEBUG;
 	    return $sref unless $sname eq $name;
 	    $refcnt{$name}++;
 	    push(@fixup, fullname($name,$idx)." = $sref");
 	    return "do{my \$fix}" if @$idx && $idx->[-1] eq '$';
 	    return "'fix'";
 	}
 	$seen{$id} = [$name, $idx];
     }
 
     if ($class) {
 	$pclass = $class;
 	$pidx = @$idx;
     }
 
     if (defined $out) {
     }
     elsif ($type eq "SCALAR" || $type eq "REF" || $type eq "REGEXP") {
 	if ($ref) {
 	    if ($class && $class eq "Regexp") {
 		my $v = "$rval";
 
 		my $mod = "";
 		if ($v =~ /^\(\?\^?([msix-]*):([\x00-\xFF]*)\)\z/) {
 		    $mod = $1;
 		    $v = $2;
 		    $mod =~ s/-.*//;
 		}
 
 		my $sep = '/';
 		my $sep_count = ($v =~ tr/\///);
 		if ($sep_count) {
 		    for ('|', ',', ':', '#') {
 			my $c = eval "\$v =~ tr/\Q$_\E//";
 			if ($c < $sep_count) {
 			    $sep = $_;
 			    $sep_count = $c;
 			    last if $sep_count == 0;
 			}
 		    }
 		}
 		$v =~ s/\Q$sep\E/\\$sep/g;
 
 		$out = "qr$sep$v$sep$mod";
 		undef($class);
 	    }
 	    else {
 		delete $seen{$id} if $type eq "SCALAR";  
 		my $val = _dump($$rval, $name, [@$idx, "\$"], 0, $pclass, $pidx);
 		$out = $class ? "do{\\(my \$o = $val)}" : "\\$val";
 	    }
 	} else {
 	    if (!defined $$rval) {
 		$out = "undef";
 	    }
 	    elsif (do {no warnings 'numeric'; $$rval + 0 eq $$rval}) {
 		$out = $$rval;
 	    }
 	    else {
 		$out = str($$rval);
 	    }
 	    if ($class && !@$idx) {
 		$refcnt{$name}++;
 		my $obj = fullname($name, $idx);
 		my $cl  = quote($class);
 		push(@fixup, "bless \\$obj, $cl");
 	    }
 	}
     }
     elsif ($type eq "GLOB") {
 	if ($ref) {
 	    delete $seen{$id};
 	    my $val = _dump($$rval, $name, [@$idx, "*"], 0, $pclass, $pidx);
 	    $out = "\\$val";
 	    if ($out =~ /^\\\*Symbol::/) {
 		$require{Symbol}++;
 		$out = "Symbol::gensym()";
 	    }
 	} else {
 	    my $val = "$$rval";
 	    $out = "$$rval";
 
 	    for my $k (qw(SCALAR ARRAY HASH)) {
 		my $gval = *$$rval{$k};
 		next unless defined $gval;
 		next if $k eq "SCALAR" && ! defined $$gval;  
 		my $f = scalar @fixup;
 		push(@fixup, "RESERVED");  
 		$gval = _dump($gval, $name, [@$idx, "*{$k}"], 0, $pclass, $pidx);
 		$refcnt{$name}++;
 		my $gname = fullname($name, $idx);
 		$fixup[$f] = "$gname = $gval";  
 	    }
 	}
     }
     elsif ($type eq "ARRAY") {
 	my @vals;
 	my $tied = tied_str(tied(@$rval));
 	my $i = 0;
 	for my $v (@$rval) {
 	    push(@vals, _dump($v, $name, [@$idx, "[$i]"], $tied, $pclass, $pidx));
 	    $i++;
 	}
 	$out = "[" . format_list(1, $tied, @vals) . "]";
     }
     elsif ($type eq "HASH") {
 	my(@keys, @vals);
 	my $tied = tied_str(tied(%$rval));
 
 	my $kstat_max = 0;
 	my $kstat_sum = 0;
 	my $kstat_sum2 = 0;
 
 	my @orig_keys = keys %$rval;
 	if ($hide_keys) {
 	    @orig_keys = grep !$hide_keys->($_), @orig_keys;
 	}
 	my $text_keys = 0;
 	for (@orig_keys) {
 	    $text_keys++, last unless /^[-+]?(?:0|[1-9]\d*)(?:\.\d+)?\z/;
 	}
 
 	if ($text_keys) {
 	    @orig_keys = sort { lc($a) cmp lc($b) } @orig_keys;
 	}
 	else {
 	    @orig_keys = sort { $a <=> $b } @orig_keys;
 	}
 
 	my $quote;
 	for my $key (@orig_keys) {
 	    next if $key =~ /^-?[a-zA-Z_]\w*\z/;
 	    next if $key =~ /^-?[1-9]\d{0,8}\z/;
 	    $quote++;
 	    last;
 	}
 
 	for my $key (@orig_keys) {
 	    my $val = \$rval->{$key};  
 	    $key = quote($key) if $quote;
 	    $kstat_max = length($key) if length($key) > $kstat_max;
 	    $kstat_sum += length($key);
 	    $kstat_sum2 += length($key)*length($key);
 
 	    push(@keys, $key);
 	    push(@vals, _dump($$val, $name, [@$idx, "{$key}"], $tied, $pclass, $pidx));
 	}
 	my $nl = "";
 	my $klen_pad = 0;
 	my $tmp = "@keys @vals";
 	if (length($tmp) > 60 || $tmp =~ /\n/ || $tied) {
 	    $nl = "\n";
 
 	    if ($kstat_max < 4) {
 		$klen_pad = $kstat_max;
 	    }
 	    elsif (@keys >= 2) {
 		my $n = @keys;
 		my $avg = $kstat_sum/$n;
 		my $stddev = sqrt(($kstat_sum2 - $n * $avg * $avg) / ($n - 1));
 
 		if ($stddev / $kstat_max < 0.25) {
 		    $klen_pad = $kstat_max;
 		}
 		if ($DEBUG) {
 		    push(@keys, "__S");
 		    push(@vals, sprintf("%.2f (%d/%.1f/%.1f)",
 					$stddev / $kstat_max,
 					$kstat_max, $avg, $stddev));
 		}
 	    }
 	}
 	$out = "{$nl";
 	$out .= "$INDENT# $tied$nl" if $tied;
 	while (@keys) {
 	    my $key = shift @keys;
 	    my $val = shift @vals;
 	    my $vpad = $INDENT . (" " x ($klen_pad ? $klen_pad + 4 : 0));
 	    $val =~ s/\n/\n$vpad/gm;
 	    my $kpad = $nl ? $INDENT : " ";
 	    $key .= " " x ($klen_pad - length($key)) if $nl && $klen_pad > length($key);
 	    $out .= "$kpad$key => $val,$nl";
 	}
 	$out =~ s/,$/ / unless $nl;
 	$out .= "}";
     }
     elsif ($type eq "CODE") {
 	$out = 'sub { ... }';
     }
     elsif ($type eq "VSTRING") {
         $out = sprintf +($ref ? '\v%vd' : 'v%vd'), $$rval;
     }
     else {
 	warn "Can't handle $type data";
 	$out = "'#$type#'";
     }
 
     if ($class && $ref) {
 	$out = "bless($out, " . quote($class) . ")";
     }
     if ($comment) {
 	$comment =~ s/^/# /gm;
 	$comment .= "\n" unless $comment =~ /\n\z/;
 	$comment =~ s/^#[ \t]+\n/\n/;
 	$out = "$comment$out";
     }
     return $out;
 }
 
 sub tied_str {
     my $tied = shift;
     if ($tied) {
 	if (my $tied_ref = ref($tied)) {
 	    $tied = "tied $tied_ref";
 	}
 	else {
 	    $tied = "tied";
 	}
     }
     return $tied;
 }
 
 sub fullname
 {
     my($name, $idx, $ref) = @_;
     substr($name, 0, 0) = "\$";
 
     my @i = @$idx;  
     if ($ref && @i && $i[0] eq "\$") {
 	shift(@i);  
 	$ref = 0;
     }
     while (@i && $i[0] eq "\$") {
 	shift @i;
 	$name = "\$$name";
     }
 
     my $last_was_index;
     for my $i (@i) {
 	if ($i eq "*" || $i eq "\$") {
 	    $last_was_index = 0;
 	    $name = "$i\{$name}";
 	} elsif ($i =~ s/^\*//) {
 	    $name .= $i;
 	    $last_was_index++;
 	} else {
 	    $name .= "->" unless $last_was_index++;
 	    $name .= $i;
 	}
     }
     $name = "\\$name" if $ref;
     $name;
 }
 
 sub format_list
 {
     my $paren = shift;
     my $comment = shift;
     my $indent_lim = $paren ? 0 : 1;
     if (@_ > 3) {
 	my $i = 0;
 	while ($i < @_) {
 	    my $j = $i + 1;
 	    my $v = $_[$i];
 	    while ($j < @_) {
 		if ($v eq "0" || $v =~ /^-?[1-9]\d{0,9}\z/) {
 		    $v++;
 		}
 		elsif ($v =~ /^"([A-Za-z]{1,3}\d*)"\z/) {
 		    $v = $1;
 		    $v++;
 		    $v = qq("$v");
 		}
 		else {
 		    last;
 		}
 		last if $_[$j] ne $v;
 		$j++;
 	    }
 	    if ($j - $i > 3) {
 		splice(@_, $i, $j - $i, "$_[$i] .. $_[$j-1]");
 	    }
 	    $i++;
 	}
     }
     my $tmp = "@_";
     if ($comment || (@_ > $indent_lim && (length($tmp) > 60 || $tmp =~ /\n/))) {
 	my @elem = @_;
 	for (@elem) { s/^/$INDENT/gm; }
 	return "\n" . ($comment ? "$INDENT# $comment\n" : "") .
                join(",\n", @elem, "");
     } else {
 	return join(", ", @_);
     }
 }
 
 sub str {
   if (length($_[0]) > 20) {
       for ($_[0]) {
       if (/^(.)\1\1\1/s) {
           unless (/[^\Q$1\E]/) {
               my $base = quote($1);
               my $repeat = length;
               return "($base x $repeat)"
           }
       }
       if (length($_) < 16 * 1024 && /^(.{2,5}?)\1*\z/s) {
 	  my $base   = quote($1);
 	  my $repeat = length($_)/length($1);
 	  return "($base x $repeat)";
       }
       }
   }
 
   local $_ = &quote;
 
   if (length($_) > 40  && !/\\x\{/ && length($_) > (length($_[0]) * 2)) {
 
       if ($TRY_BASE64 && length($_[0]) > $TRY_BASE64 &&
 	  (defined &utf8::is_utf8 && !utf8::is_utf8($_[0])) &&
 	  eval { require MIME::Base64 })
       {
 	  $require{"MIME::Base64"}++;
 	  return "MIME::Base64::decode(\"" .
 	             MIME::Base64::encode($_[0],"") .
 		 "\")";
       }
       return "pack(\"H*\",\"" . unpack("H*", $_[0]) . "\")";
   }
 
   return $_;
 }
 
 my %esc = (
     "\a" => "\\a",
     "\b" => "\\b",
     "\t" => "\\t",
     "\n" => "\\n",
     "\f" => "\\f",
     "\r" => "\\r",
     "\e" => "\\e",
 );
 
 sub quote {
   local($_) = $_[0];
   s/([\\\"\@\$])/\\$1/g;
   return qq("$_") unless /[^\040-\176]/;  
 
   s/([\a\b\t\n\f\r\e])/$esc{$1}/g;
 
   s/([\0-\037])(?!\d)/sprintf('\\%o',ord($1))/eg;
 
   s/([\0-\037\177-\377])/sprintf('\\x%02X',ord($1))/eg;
   s/([^\040-\176])/sprintf('\\x{%X}',ord($1))/eg;
 
   return qq("$_");
 }
 
 1;
 
 __END__
 
### Data/Dump/FilterContext.pm ###
 package Data::Dump::FilterContext;
 
 sub new {
     my($class, $obj, $oclass, $type, $ref, $pclass, $pidx, $idx) = @_;
     return bless {
 	object => $obj,
 	class => $ref && $oclass,
 	reftype => $type,
 	is_ref => $ref,
 	pclass => $pclass,
 	pidx => $pidx,
 	idx => $idx,
     }, $class;
 }
 
 sub object_ref {
     my $self = shift;
     return $self->{object};
 }
 
 sub class {
     my $self = shift;
     return $self->{class} || "";
 }
 
 *is_blessed = \&class;
 
 sub reftype {
     my $self = shift;
     return $self->{reftype};
 }
 
 sub is_scalar {
     my $self = shift;
     return $self->{reftype} eq "SCALAR";
 }
 
 sub is_array {
     my $self = shift;
     return $self->{reftype} eq "ARRAY";
 }
 
 sub is_hash {
     my $self = shift;
     return $self->{reftype} eq "HASH";
 }
 
 sub is_code {
     my $self = shift;
     return $self->{reftype} eq "CODE";
 }
 
 sub is_ref {
     my $self = shift;
     return $self->{is_ref};
 }
 
 sub container_class {
     my $self = shift;
     return $self->{pclass} || "";
 }
 
 sub container_self {
     my $self = shift;
     return "" unless $self->{pclass};
     my $idx = $self->{idx};
     my $pidx = $self->{pidx};
     return Data::Dump::fullname("self", [@$idx[$pidx..(@$idx - 1)]]);
 }
 
 sub expr {
     my $self = shift;
     my $top = shift || "var";
     $top =~ s/^\$//; 
     my $idx = $self->{idx};
     return Data::Dump::fullname($top, $idx);
 }
 
 sub object_isa {
     my($self, $class) = @_;
     return $self->{class} && $self->{class}->isa($class);
 }
 
 sub container_isa {
     my($self, $class) = @_;
     return $self->{pclass} && $self->{pclass}->isa($class);
 }
 
 sub depth {
     my $self = shift;
     return scalar @{$self->{idx}};
 }
 
 1;
### Data/Dump/Filtered.pm ###
 package Data::Dump::Filtered;
 
 use Data::Dump ();
 use Carp ();
 
 use base 'Exporter';
 our @EXPORT_OK = qw(add_dump_filter remove_dump_filter dump_filtered);
 
 sub add_dump_filter {
     my $filter = shift;
     unless (ref($filter) eq "CODE") {
 	Carp::croak("add_dump_filter argument must be a code reference");
     }
     push(@Data::Dump::FILTERS, $filter);
     return $filter;
 }
 
 sub remove_dump_filter {
     my $filter = shift;
     @Data::Dump::FILTERS = grep $_ ne $filter, @Data::Dump::FILTERS;
 }
 
 sub dump_filtered {
     my $filter = pop;
     if (defined($filter) && ref($filter) ne "CODE") {
 	Carp::croak("Last argument to dump_filtered must be undef or a code reference");
     }
     local @Data::Dump::FILTERS = ($filter ? $filter : ());
     return &Data::Dump::dump;
 }
 
 1;
 
### Data/Dump/OneLine.pm ###
 package Data::Dump::OneLine;
 
 our $DATE = '2015-03-25'; 
 our $VERSION = '0.07'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Data::Dmp;
 
 our @ISA = qw(Data::Dmp);
 our @EXPORT = (@Data::Dmp::EXPORT, 'dump1', 'dump_one_line');
 
 *dump1 = \&Data::Dmp::dmp;
 *dump_one_line = \&Data::Dmp::dmp;
 
 1;
 
 __END__
 
### Data/Dump/Partial.pm ###
 package Data::Dump::Partial;
 
 use 5.010001;
 use strict;
 use warnings;
 use experimental 'smartmatch';
 use Data::Dump::Filtered;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(dump_partial dumpp);
 
 our $VERSION = '0.05'; 
 
 sub _dmp { Data::Dump::Filtered::dump_filtered(@_, undef) }
 
 sub dump_partial {
     my @data = @_;
     die 'Usage: dump_partial(@data, \%opts)'
         if @data > 1 && ref($data[-1]) ne 'HASH';
     my $opts = (@data > 1) ? {%{pop(@data)}} : {};
 
     $opts->{max_keys}      //=  5;
     $opts->{max_elems}     //=  5;
     $opts->{max_len}       //= 32;
     $opts->{max_total_len} //= 80;
 
     $opts->{max_keys} = @{$opts->{precious_keys}} if $opts->{precious_keys} &&
         @{ $opts->{precious_keys} } > $opts->{max_keys};
 
     my $out;
 
     if ($opts->{_inner}) {
         $out = Data::Dump::dump(@data);
     } else {
         my $filter = sub {
             my ($ctx, $oref) = @_;
 
             my $skip_modify_outermost_hash;
             if ($opts->{_skip_modify_outermost_hash}) {
                 $skip_modify_outermost_hash++;
                 $opts->{_skip_modify_outermost_hash}--;
             }
 
             if ($opts->{max_len} && $ctx->is_scalar && defined($$oref) &&
                     length($$oref) > $opts->{max_len}) {
 
                 return { object => substr($$oref, 0, $opts->{max_len}-3)."..." };
 
             } elsif ($opts->{max_elems} && $ctx->is_array &&
                          @$oref > $opts->{max_elems}) {
 
                 my @ary = @{$oref}[0..($opts->{max_elems}-1)];
                 local $opts->{_inner} = 1;
                 local $opts->{max_total_len} = 0;
                 my $out = dump_partial(\@ary, $opts);
                 $out =~ s/(?:, )?]$/, ...]/;
                 return { dump => $out };
 
             } elsif ($ctx->is_hash) {
 
                 my %hash;
                 my $modified;
 
                 if ($opts->{pair_filter} && !$skip_modify_outermost_hash) {
                     for (sort keys %$oref) {
                         my @res = $opts->{pair_filter}->($_, $oref->{$_});
                         $modified = "pair_filter" unless @res == 2 &&
                             $res[0] eq $_ && "$res[1]" eq "$oref->{$_}";
                         while (my ($k, $v) = splice @res, 0, 2) {
                             $hash{$k} = $v;
                         }
                     }
                 } else {
                     %hash = %$oref;
                 }
 
                 if ($opts->{mask_keys_regex} && !$skip_modify_outermost_hash) {
                     for (sort keys %hash) {
                         if (/$opts->{mask_keys_regex}/) {
                             $modified = "mask_keys_regex";
                             $hash{$_} = '***';
                         }
                     }
                 }
 
                 my $truncated;
                 if ($opts->{max_keys} && keys(%$oref) > $opts->{max_keys}) {
                     my $mk = $opts->{max_keys};
                     {
                         if ($opts->{hide_keys}) {
                             for (sort keys %hash) {
                                 delete $hash{$_} if $_ ~~ @{$opts->{hide_keys}};
                             }
                         }
                         last if keys(%hash) <= $mk;
                         if ($opts->{worthless_keys}) {
                             for (sort keys %hash) {
                                 last if keys(%hash) <= $mk;
                                 delete $hash{$_} if $_ ~~ @{$opts->{worthless_keys}};
                             }
                         }
                         last if keys(%hash) <= $mk;
                         for (reverse sort keys %hash) {
                             delete $hash{$_} if !$opts->{precious_keys} ||
                                 !($_ ~~ @{$opts->{precious_keys}});
                             last if keys(%hash) <= $mk;
                         }
                     }
                     $modified = "truncate";
                     $truncated++;
                 }
 
                 if ($modified) {
                     local $opts->{_inner} = 1;
                     local $opts->{_skip_modify_outermost_hash} = 1;
                     local $opts->{max_total_len} = 0;
                     my $out = dump_partial(\%hash, $opts);
                     $out =~ s/(?:, )? }$/, ... }/ if $truncated;
                     return { dump => $out };
                 }
             }
 
             if ($opts->{dd_filter}) {
                 return $opts->{dd_filter}->($ctx, $oref);
             } else {
                 return;
             }
         };
         $out = Data::Dump::Filtered::dump_filtered(@data, $filter);
     }
 
     for ($out) {
         s/^\s*#.*//mg; 
         s/^\s+//mg; 
         s/\n+/ /g; 
     }
 
     if ($opts->{max_total_len} && length($out) > $opts->{max_total_len}) {
         $out = substr($out, 0, $opts->{max_total_len}-3) . "...";
     }
 
     print STDERR "$out\n" unless defined wantarray;
     $out;
 }
 
 sub dumpp { dump_partial(@_) }
 
 1;
 
 __END__
 
### Data/Dump/Trace.pm ###
 package Data::Dump::Trace;
 
 $VERSION = "0.02";
 
 
 use strict;
 
 use base 'Exporter';
 our @EXPORT_OK = qw(call mcall wrap autowrap trace);
 
 use Carp qw(croak);
 use overload ();
 
 my %obj_name;
 my %autowrap_class;
 my %name_count;
 
 sub autowrap {
     while (@_) {
         my $class = shift;
         my $info = shift;
         $info = { prefix => $info } unless ref($info);
         for ($info->{prefix}) {
             unless ($_) {
                 $_ = lc($class);
                 s/.*:://;
             }
             $_ = '$' . $_ unless /^\$/;
         }
         $autowrap_class{$class} = $info;
     }
 }
 
 sub wrap {
     my %arg = @_;
     my $name = $arg{name} || "func";
     my $func = $arg{func};
     my $proto = $arg{proto};
 
     return sub {
         call($name, $func, $proto, @_);
     } if $func;
 
     if (my $obj = $arg{obj}) {
         $name = '$' . $name unless $name =~ /^\$/;
         $obj_name{overload::StrVal($obj)} = $name;
         return bless {
             name => $name,
             obj => $obj,
             proto => $arg{proto},
         }, "Data::Dump::Trace::Wrapper";
     }
 
     croak("Either the 'func' or 'obj' option must be given");
 }
 
 sub trace {
     my($symbol, $prototype) = @_;
     no strict 'refs';
     no warnings 'redefine';
     *{$symbol} = wrap(name => $symbol, func => \&{$symbol}, proto => $prototype);
 }
 
 sub call {
     my $name = shift;
     my $func = shift;
     my $proto = shift;
     my $fmt = Data::Dump::Trace::Call->new($name, $proto, \@_);
     if (!defined wantarray) {
         $func->(@_);
         return $fmt->return_void(\@_);
     }
     elsif (wantarray) {
         return $fmt->return_list(\@_, $func->(@_));
     }
     else {
         return $fmt->return_scalar(\@_, scalar $func->(@_));
     }
 }
 
 sub mcall {
     my $o = shift;
     my $method = shift;
     my $proto = shift;
     return if $method eq "DESTROY" && !$o->can("DESTROY");
     my $oname = ref($o) ? $obj_name{overload::StrVal($o)} || "\$o" : $o;
     my $fmt = Data::Dump::Trace::Call->new("$oname->$method", $proto, \@_);
     if (!defined wantarray) {
         $o->$method(@_);
         return $fmt->return_void(\@_);
     }
     elsif (wantarray) {
         return $fmt->return_list(\@_, $o->$method(@_));
     }
     else {
         return $fmt->return_scalar(\@_, scalar $o->$method(@_));
     }
 }
 
 package Data::Dump::Trace::Wrapper;
 
 sub AUTOLOAD {
     my $self = shift;
     our $AUTOLOAD;
     my $method = substr($AUTOLOAD, rindex($AUTOLOAD, '::')+2);
     Data::Dump::Trace::mcall($self->{obj}, $method, $self->{proto}{$method}, @_);
 }
 
 package Data::Dump::Trace::Call;
 
 use Term::ANSIColor ();
 use Data::Dump ();
 
 *_dump = \&Data::Dump::dump;
 
 our %COLOR = (
     name => "yellow",
     output => "cyan",
     error => "red",
     debug => "red",
 );
 
 %COLOR = () unless -t STDOUT;
 
 sub _dumpav {
     return "(" . _dump(@_) . ")" if @_ == 1;
     return _dump(@_);
 }
 
 sub _dumpkv {
     return _dumpav(@_) if @_ % 2;
     my %h = @_;
     my $str = _dump(\%h);
     $str =~ s/^\{/(/ && $str =~ s/\}\z/)/;
     return $str;
 }
 
 sub new {
     my($class, $name, $proto, $input_args) = @_;
     my $self = bless {
         name => $name,
         proto => $proto,
     }, $class;
     my $proto_arg = $self->proto_arg;
     if ($proto_arg =~ /o/) {
         for (@$input_args) {
             push(@{$self->{input_av}}, _dump($_));
         }
     }
     else {
         $self->{input} = $proto_arg eq "%" ? _dumpkv(@$input_args) : _dumpav(@$input_args);
     }
     return $self;
 }
 
 sub proto_arg {
     my $self = shift;
     my($arg, $ret) = split(/\s*=\s*/, $self->{proto} || "");
     $arg ||= '@';
     return $arg;
 }
 
 sub proto_ret {
     my $self = shift;
     my($arg, $ret) = split(/\s*=\s*/, $self->{proto} || "");
     $ret ||= '@';
     return $ret;
 }
 
 sub color {
     my($self, $category, $text) = @_;
     return $text unless $COLOR{$category};
     return Term::ANSIColor::colored($text, $COLOR{$category});
 }
 
 sub print_call {
     my $self = shift;
     my $outarg = shift;
     print $self->color("name", "$self->{name}");
     if (my $input = $self->{input}) {
         $input = "" if $input eq "()" && $self->{name} =~ /->/;
         print $self->color("input", $input);
     }
     else {
         my $proto_arg = $self->proto_arg;
         print "(";
         my $i = 0;
         for (@{$self->{input_av}}) {
             print ", " if $i;
             my $proto = substr($proto_arg, 0, 1, "");
             if ($proto ne "o") {
                 print $self->color("input", $_);
             }
             if ($proto eq "o" || $proto eq "O") {
                 print " = " if $proto eq "O";
                 print $self->color("output", _dump($outarg->[$i]));
             }
         }
         continue {
             $i++;
         }
         print ")";
     }
 }
 
 sub return_void {
     my $self = shift;
     my $arg = shift;
     $self->print_call($arg);
     print "\n";
     return;
 }
 
 sub return_scalar {
     my $self = shift;
     my $arg = shift;
     $self->print_call($arg);
     my $s = shift;
     my $name;
     my $proto_ret = $self->proto_ret;
     my $wrap = $autowrap_class{ref($s)};
     if ($proto_ret =~ /^\$\w+\z/ && ref($s) && ref($s) !~ /^(?:ARRAY|HASH|CODE|GLOB)\z/) {
         $name = $proto_ret;
     }
     else {
         $name = $wrap->{prefix} if $wrap;
     }
     if ($name) {
         $name .= $name_count{$name} if $name_count{$name}++;
         print " = ", $self->color("output", $name), "\n";
         $s = Data::Dump::Trace::wrap(name => $name, obj => $s, proto => $wrap->{proto});
     }
     else {
         print " = ", $self->color("output", _dump($s));
         if (!$s && $proto_ret =~ /!/ && $!) {
             print " ", $self->color("error", errno($!));
         }
         print "\n";
     }
     return $s;
 }
 
 sub return_list {
     my $self = shift;
     my $arg = shift;
     $self->print_call($arg);
     print " = ", $self->color("output", $self->proto_ret eq "%" ? _dumpkv(@_) : _dumpav(@_)), "\n";
     return @_;
 }
 
 sub errno {
     my $t = "";
     for (keys %!) {
         if ($!{$_}) {
             $t = $_;
             last;
         }
     }
     my $n = int($!);
     return "$t($n) $!";
 }
 
 1;
 
 __END__
 
### Data/Format/Pretty.pm ###
 package Data::Format::Pretty;
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Module::Load;
 use Module::Loaded;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT    = qw(ppr);
 our @EXPORT_OK = qw(format_pretty print_pretty ppr);
 
 our $VERSION = '0.04'; 
 
 sub format_pretty {
     my ($data, $opts0) = @_;
 
     my %opts = $opts0 ? %$opts0 : ();
     my $module = $opts{module};
     if (!$module) {
         if ($ENV{GATEWAY_INTERFACE} || $ENV{PLACK_ENV}) {
             $module = 'HTML';
         } else {
             $module = 'Console';
         }
     }
     delete $opts{module};
 
     my $module_full = "Data::Format::Pretty::" . $module;
     load $module_full unless is_loaded $module_full;
     my $sub = \&{$module_full . "::format_pretty"};
 
     $sub->($data, \%opts);
 }
 
 sub print_pretty {
     print format_pretty(@_);
 }
 
 *ppr = \&print_pretty;
 
 1;
 
 
 
 
 __END__
 
### Data/Format/Pretty/CompactJSON.pm ###
 package Data::Format::Pretty::CompactJSON;
 
 use 5.010;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(format_pretty);
 
 our $VERSION = '0.11'; 
 
 sub content_type { "application/json" }
 
 sub format_pretty {
     my ($data, $opts) = @_;
     state $json;
 
     $opts //= {};
 
     if ($opts->{color} // $ENV{COLOR} // (-t STDOUT)) {
         require JSON::Color;
         JSON::Color::encode_json($data, {pretty=>0, linum=>0});
     } else {
         if (!$json) {
             require JSON;
             $json = JSON->new->utf8->allow_nonref;
         }
         $json->encode($data);
     }
 }
 
 1;
 
 __END__
 
### Data/Format/Pretty/Console.pm ###
 package Data::Format::Pretty::Console;
 
 our $DATE = '2015-10-20'; 
 our $VERSION = '0.35'; 
 
 use 5.010001;
 use strict;
 use warnings;
 use experimental 'smartmatch';
 use Log::Any::IfLOG '$log';
 
 use Scalar::Util qw(blessed);
 use Text::ANSITable;
 use YAML::Any;
 use JSON;
 
 my $json = JSON->new->allow_nonref;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(format_pretty);
 
 sub content_type { "text/plain" }
 
 sub format_pretty {
     my ($data, $opts) = @_;
     $opts //= {};
     __PACKAGE__->new($opts)->_format($data);
 }
 
 sub new {
     my ($class, $opts) = @_;
     $opts //= {};
     $opts->{interactive} //= $ENV{INTERACTIVE} // (-t STDOUT);
     $opts->{table_column_orders} //= $json->decode(
         $ENV{FORMAT_PRETTY_TABLE_COLUMN_ORDERS})
         if defined($ENV{FORMAT_PRETTY_TABLE_COLUMN_ORDERS});
     $opts->{table_column_formats} //= $json->decode(
         $ENV{FORMAT_PRETTY_TABLE_COLUMN_FORMATS})
         if defined($ENV{FORMAT_PRETTY_TABLE_COLUMN_FORMATS});
     $opts->{table_column_types} //= $json->decode(
         $ENV{FORMAT_PRETTY_TABLE_COLUMN_TYPES})
         if defined($ENV{FORMAT_PRETTY_TABLE_COLUMN_TYPES});
     $opts->{list_max_columns} //= $ENV{FORMAT_PRETTY_LIST_MAX_COLUMNS};
     bless {opts=>$opts}, $class;
 }
 
 sub _is_cell_or_format_cell {
     my ($self, $data, $is_format) = @_;
 
     my $maxlen = 1000;
 
     if (!ref($data) || blessed($data)) {
         if (!defined($data)) {
             return "" if $is_format;
             return 1;
         }
         if (length($data) > $maxlen) {
             return;
         }
         return "$data" if $is_format;
         return 1;
     } elsif (ref($data) eq 'ARRAY') {
         if (grep {ref($_) && !blessed($_)} @$data) {
             return;
         }
         my $s = join(", ", map {defined($_) ? "$_":""} @$data);
         if (length($s) > $maxlen) {
             return;
         }
         return $s if $is_format;
         return 1;
     } else {
         return;
     }
 }
 
 sub _format_cell { _is_cell_or_format_cell(@_, 1) }
 
 sub _is_cell     { _is_cell_or_format_cell(@_, 0) }
 
 sub _detect_struct {
     my ($self, $data) = @_;
     my $struct;
     my $struct_meta = {};
 
   CHECK_FORMAT:
     {
       CHECK_SCALAR:
         {
             if (!ref($data) || blessed($data)) {
                 $struct = "scalar";
                 last CHECK_FORMAT;
             }
         }
 
       CHECK_AOA:
         {
             if (ref($data) eq 'ARRAY') {
                 my $numcols;
                 for my $row (@$data) {
                     last CHECK_AOA unless ref($row) eq 'ARRAY';
                     last CHECK_AOA if defined($numcols) && $numcols != @$row;
                     last CHECK_AOA if grep { !$self->_is_cell($_) } @$row;
                     $numcols = @$row;
                 }
                 $struct = "aoa";
                 last CHECK_FORMAT;
             }
         }
 
       CHECK_AOH:
         {
             if (ref($data) eq 'ARRAY') {
                 $struct_meta->{columns} = {};
                 for my $row (@$data) {
                     last CHECK_AOH unless ref($row) eq 'HASH';
                     for my $k (keys %$row) {
                         last CHECK_AOH if !$self->_is_cell($row->{$k});
                         $struct_meta->{columns}{$k} = 1;
                     }
                 }
                 $struct = "aoh";
                 last CHECK_FORMAT;
             }
         }
 
       CHECK_LIST:
         {
             if (ref($data) eq 'ARRAY') {
                 for (@$data) {
                     last CHECK_LIST unless $self->_is_cell($_);
                 }
                 $struct = "list";
                 last CHECK_FORMAT;
             }
         }
 
       CHECK_HOT:
         {
             last CHECK_HOT if $self->{opts}{skip_hot};
             last CHECK_HOT unless ref($data) eq 'HASH';
             my $has_t;
             while (my ($k, $v) = each %$data) {
                 my ($s2, $sm2) = $self->_detect_struct($v, {skip_hot=>1});
                 last CHECK_HOT unless $s2;
                 $has_t = 1 if $s2 =~ /^(?:list|aoa|aoh|hash)$/;
             }
             last CHECK_HOT unless $has_t;
             $struct = "hot";
             last CHECK_FORMAT;
         }
 
       CHECK_HASH:
         {
             if (ref($data) eq 'HASH') {
                 for (values %$data) {
                     last CHECK_HASH unless $self->_is_cell($_);
                 }
                 $struct = "hash";
                 last CHECK_FORMAT;
             }
         }
 
     }
 
     ($struct, $struct_meta);
 }
 
 sub _render_table {
     my ($self, $t) = @_;
 
     my $colfmts;
     my $tcff = $self->{opts}{table_column_formats};
     if ($tcff) {
         for my $tcf (@$tcff) {
             my $match = 1;
             my @tcols = @{ $t->{cols} };
             for my $scol (keys %$tcf) {
                 do { $match = 0; last } unless $scol ~~ @tcols;
             }
             if ($match) {
                 $colfmts = $tcf;
                 last;
             }
         }
     }
 
     my $coltypes;
     my $tctt = $self->{opts}{table_column_types};
     if ($tctt) {
         for my $tct (@$tctt) {
             my $match = 1;
             my @tcols = @{ $t->{cols} };
             for my $scol (keys %$tct) {
                 do { $match = 0; last } unless $scol ~~ @tcols;
             }
             if ($match) {
                 $coltypes = $tct;
                 last;
             }
         }
     }
 
     my $at = Text::ANSITable->new;
     $at->columns($t->{cols});
     $at->rows($t->{rows});
     if ($t->{at_opts}) {
         $at->{$_} = $t->{at_opts}{$_} for keys %{ $t->{at_opts} };
     }
     if ($colfmts) {
         $at->set_column_style($_ => formats => $colfmts->{$_})
             for keys %$colfmts;
     }
     if ($coltypes) {
         $at->set_column_style($_ => type => $coltypes->{$_})
             for keys %$coltypes;
     }
     if ($t->{col_widths}) {
         $at->set_column_style($_ => width => $t->{col_widths}{$_})
             for keys %{ $t->{col_widths} };
     }
     $at->draw;
 }
 
 sub _format_unknown {
     my ($self, $data) = @_;
     Dump($data);
 }
 
 sub _format_scalar {
     my ($self, $data) = @_;
 
     my $sdata = defined($data) ? "$data" : "";
     return "" if !length($sdata);
     return $sdata =~ /\n\z/s ? $sdata : "$sdata\n";
 }
 
 sub _format_list {
     my ($self, $data) = @_;
     if ($self->{opts}{interactive}) {
 
         require List::Util;
         require POSIX;
 
 
         my @rows = map { $self->_format_cell($_) } @$data;
 
         my $maxwidth = List::Util::max(map { length } @rows) // 0;
         my ($termcols, $termrows);
         if ($ENV{COLUMNS}) {
             $termcols = $ENV{COLUMNS};
         } elsif (eval { require Term::Size; 1 }) {
             ($termcols, $termrows) = Term::Size::chars();
         } else {
             $termcols = $^O =~ /Win/ ? 79 : 80;
         }
         my $numcols = 1;
         if ($maxwidth) {
             $numcols = int( (($termcols-1)-$maxwidth-6)/(3+$maxwidth) + 1 );
             $numcols = @rows if $numcols > @rows;
             $numcols = 1 if $numcols < 1;
         }
         $numcols = $self->{opts}{list_max_columns}
             if defined($self->{opts}{list_max_columns}) &&
                 $numcols > $self->{opts}{list_max_columns};
         my $numrows = POSIX::ceil(@rows/$numcols);
         if ($numrows) {
             $numcols = POSIX::ceil(@rows/$numrows);
         }
 
         my $t = {rows=>[], at_opts=>{show_header=>0}};
         $t->{cols} = [map { "c$_" } 1..$numcols];
         if ($numcols > 1) {
             $t->{col_widths}{"c$_"} = $maxwidth for 1..$numcols;
         }
         for my $r (1..$numrows) {
             my @trow;
             for my $c (1..$numcols) {
                 my $idx = ($c-1)*$numrows + ($r-1);
                 push @trow, $idx < @rows ? $rows[$idx] : '';
             }
             push @{$t->{rows}}, \@trow;
         }
 
         return $self->_render_table($t);
 
     } else {
         my @rows;
         for my $row (@$data) {
             push @rows, ($row // "") . "\n";
         }
         return join("", @rows);
     }
 }
 
 sub _format_hash {
     my ($self, $data) = @_;
     if ($self->{opts}{interactive}) {
         my $t = {cols=>[qw/key value/], rows=>[],
                  at_opts=>{}};
         for my $k (sort keys %$data) {
             push @{ $t->{rows} }, [$k, $self->_format_cell($data->{$k})];
         }
         return $self->_render_table($t);
     } else {
         my @t;
         for my $k (sort keys %$data) {
             push @t, $k, "\t", ($data->{$k} // ""), "\n";
         }
         return join("", @t);
     }
 }
 
 sub _format_aoa {
     my ($self, $data) = @_;
     if ($self->{opts}{interactive}) {
         if (@$data) {
             my $t = {rows=>[], at_opts=>{}};
             $t->{cols} = [map { "column$_" } 0..@{ $data->[0] }-1];
             for my $i (0..@$data-1) {
                 push @{ $t->{rows} },
                     [map {$self->_format_cell($_)} @{ $data->[$i] }];
             }
             return $self->_render_table($t);
         } else {
             return "";
         }
     } else {
         my @t;
         for my $row (@$data) {
             push @t, join("\t", map { $self->_format_cell($_) } @$row) .
                 "\n";
         }
         return join("", @t);
     }
 }
 
 sub _format_aoh {
     my ($self, $data, $struct_meta) = @_;
     my @cols = @{ $self->_order_table_columns(
         [keys %{$struct_meta->{columns}}]) };
     if ($self->{opts}{interactive}) {
         my $t = {cols=>\@cols, rows=>[]};
         for my $i (0..@$data-1) {
             my $row = $data->[$i];
             push @{ $t->{rows} }, [map {$self->_format_cell($row->{$_})} @cols];
         }
         return $self->_render_table($t);
     } else {
         my @t;
         for my $row (@$data) {
             my @row = map {$self->_format_cell($row->{$_})} @cols;
             push @t, join("\t", @row) . "\n";
         }
         return join("", @t);
     }
 }
 
 sub _format_hot {
     my ($self, $data) = @_;
     my @t;
     for my $k (sort keys %$data) {
         push @t, "$k:\n", $self->_format($data->{$k}), "\n";
     }
     return join("", @t);
 }
 
 sub _format {
     my ($self, $data) = @_;
 
     my ($struct, $struct_meta) = $self->_detect_struct($data);
 
     if (!$struct) {
         return $self->_format_unknown($data, $struct_meta);
     } elsif ($struct eq 'scalar') {
         return $self->_format_scalar($data, $struct_meta);
     } elsif ($struct eq 'list') {
         return $self->_format_list($data, $struct_meta);
     } elsif ($struct eq 'hash') {
         return $self->_format_hash($data, $struct_meta);
     } elsif ($struct eq 'aoa') {
         return $self->_format_aoa($data, $struct_meta);
     } elsif ($struct eq 'aoh') {
         return $self->_format_aoh($data, $struct_meta);
     } elsif ($struct eq 'hot') {
         return $self->_format_hot($data, $struct_meta);
     } else {
         die "BUG: Unknown format `$struct`";
     }
 }
 
 sub _order_table_columns {
     my ($self, $cols) = @_;
 
     my $found; 
     my $tco = $self->{opts}{table_column_orders};
     my %orders; 
     if ($tco) {
         die "table_column_orders should be an arrayref"
             unless ref($tco) eq 'ARRAY';
       CO:
         for my $co (@$tco) {
             die "table_column_orders elements must all be arrayrefs"
                 unless ref($co) eq 'ARRAY';
             for (@$co) {
                 next CO unless $_ ~~ @$cols;
             }
 
             $found++;
             for (my $i=0; $i<@$co; $i++) {
                 $orders{$co->[$i]} = $i;
             }
             $found++;
             last CO;
         }
     }
 
     my @ocols;
     if ($found) {
         @ocols = sort {
             (defined($orders{$a}) && defined($orders{$b}) ?
                  $orders{$a} <=> $orders{$b} : 0)
                 || $a cmp $b
         } (sort @$cols);
     } else {
         @ocols = sort @$cols;
     }
 
     \@ocols;
 }
 
 1;
 
 __END__
 
### Data/Format/Pretty/HTML.pm ###
 package Data::Format::Pretty::HTML;
 
 use 5.010001;
 use strict;
 use warnings;
 use Log::Any::IfLOG '$log';
 
 use Data::Format::Pretty::Console 0.24;
 use HTML::Entities;
 use Scalar::Util qw(looks_like_number);
 use URI::Find::Schemeless;
 use YAML::Any;
 
 require Exporter;
 our @ISA = qw(Exporter Data::Format::Pretty::Console);
 our @EXPORT_OK = qw(format_pretty);
 
 our $VERSION = '0.10'; 
 
 sub content_type { "text/html" }
 
 sub format_pretty {
     my ($data, $opts) = @_;
     $opts //= {};
     __PACKAGE__->new($opts)->_format($data);
 }
 
 sub new {
     my ($class, $opts) = @_;
     my $obj = $class->SUPER::new($opts);
     $obj->{opts}{linkify_urls_in_text} //= 1;
     $obj->{opts}{interactive} = 1;
     $obj->{opts}{list_max_columns} = 1;
     $obj;
 }
 
 sub _htmlify {
     my ($self, $text) = @_;
 
     $text = encode_entities($text);
     if ($self->{opts}{linkify_urls_in_text}) {
         URI::Find::Schemeless->new(
             sub {
                 my $uri = decode_entities $_[0];
                 return qq|<a href="$uri">$uri</a>|;
             })->find(\$text);
     }
     if ($text =~ /\R/) {
         return "<pre>$text</pre>";
     } else {
         return $text;
     }
 }
 
 sub _render_table {
     my ($self, $t) = @_;
     my @t = ("<table>\n");
 
     my $sh = $t->{at_opts}{show_header};
     unless (defined($sh) && !$sh) {
         push @t, "  <thead>\n";
         push @t, "    <tr>";
         for my $c (@{$t->{cols}}) {
             push @t, (
                 "<th", (looks_like_number($c) ? ' class="number"':''), ">",
                 $self->_htmlify($c),
                 "</th>",
             );
         }
         push @t, "</tr>\n";
         push @t, "  </thead>\n";
     }
 
     push @t, "  <tbody>\n";
     for my $r (@{$t->{rows}}) {
         push @t, "    <tr>";
         my $cidx = 0;
         for my $c (@$r) {
             if ($t->{html_cols} && $t->{html_cols}[$cidx]) {
                 push @t, "<td>", $c, "</td>";
             } else {
                 push @t, (
                     "<td", (looks_like_number($c) ? ' class="number"':''), ">",
                     $self->_htmlify($c),
                     "</td>",
                 );
             }
             $cidx++;
         }
         push @t, "</tr>\n";
     }
     push @t, "  </tbody>\n";
     push @t, "</table>\n";
     join "", @t;
 }
 
 sub _format_unknown {
     my ($self, $data) = @_;
     $self->_htmlify(Dump $data);
 }
 
 sub _format_scalar {
     my ($self, $data) = @_;
 
     my $sdata = defined($data) ? "$data" : "";
     $self->_htmlify($sdata);
 }
 
 sub _format_hot {
     my ($self, $data) = @_;
     my @t;
     my $t = {cols=>[qw/key value/], html_cols=>[0, 1], rows=>[]};
     for my $k (sort keys %$data) {
         push @{ $t->{rows} }, [$k, $self->_format($data->{$k})];
     }
     $self->_render_table($t);
 }
 
 1;
 
 __END__
 
### Data/Format/Pretty/JSON.pm ###
 package Data::Format::Pretty::JSON;
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(format_pretty);
 
 our $VERSION = '0.11'; 
 
 sub content_type { "application/json" }
 
 sub format_pretty {
     my ($data, $opts) = @_;
     $opts //= {};
 
     state $json;
     my $interactive = (-t STDOUT);
     my $pretty = $opts->{pretty} // 1;
     my $color  = $opts->{color} // $ENV{COLOR} // $interactive //
         $opts->{pretty};
     my $linum  = $opts->{linum} // $ENV{LINUM} // 0;
     if ($color) {
         require JSON::Color;
         JSON::Color::encode_json($data, {pretty=>$pretty, linum=>$linum})."\n";
     } else {
         if (!$json) {
             require JSON;
             $json = JSON->new->utf8->allow_nonref;
         }
         $json->pretty($pretty);
         if ($linum) {
             require String::LineNumber;
             String::LineNumber::linenum($json->encode($data));
         } else {
             $json->encode($data);
         }
     }
 }
 
 1;
 
 __END__
 
### Data/Format/Pretty/SimpleText.pm ###
 package Data::Format::Pretty::SimpleText;
 
 use 5.010;
 use strict;
 use warnings;
 
 use Data::Format::Pretty::Console ();
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(format_pretty);
 
 our $VERSION = '0.35'; 
 
 sub content_type { "text/plain" }
 
 sub format_pretty {
     my ($data, $opts) = @_;
     my %opts = $opts ? %$opts : ();
     $opts{interactive} = 0;
     Data::Format::Pretty::Console::format_pretty($data, \%opts);
 }
 
 1;
 
 __END__
 
### Data/Format/Pretty/Text.pm ###
 package Data::Format::Pretty::Text;
 
 use 5.010;
 use strict;
 use warnings;
 
 use Data::Format::Pretty::Console ();
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(format_pretty);
 
 our $VERSION = '0.35'; 
 
 sub content_type { "text/plain" }
 
 sub format_pretty {
     my ($data, $opts) = @_;
     my %opts = $opts ? %$opts : ();
     $opts{interactive} = 1;
     Data::Format::Pretty::Console::format_pretty($data, \%opts);
 }
 
 1;
 
 __END__
 
### Data/ModeMerge.pm ###
 package Data::ModeMerge;
 
 our $DATE = '2015-02-21'; 
 our $VERSION = '0.32'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT = qw(mode_merge);
 
 sub mode_merge {
     my ($l, $r, $config_vars) = @_;
     my $mm = __PACKAGE__->new(config => $config_vars);
     $mm->merge($l, $r);
 }
 
 has config => (is => "rw");
 
 has modes => (is => 'rw', default => sub { {} });
 
 has combine_rules => (is => 'rw');
 
 has path => (is => "rw", default => sub { [] });
 has errors => (is => "rw", default => sub { [] });
 has mem => (is => "rw", default => sub { {} }); 
 has cur_mem_key => (is => "rw"); 
 
 sub _dump {
     require Data::Dumper;
 
     my ($self, $var) = @_;
     Data::Dumper->new([$var])->Indent(0)->Terse(1)->Sortkeys(1)->Dump;
 }
 
 sub _in($$) {
     my ($self, $needle, $haystack) = @_;
     return 0 unless defined($needle);
     my $r1 = ref($needle);
     my $f1 = $r1 ? $self->_dump($needle) : undef;
     for (@$haystack) {
         my $r2 = ref($_);
         next if $r1 xor $r2;
         return 1 if  $r2 && $f1 eq $self->_dump($_);
         return 1 if !$r2 && $needle eq $_;
     }
     0;
 }
 
 sub BUILD {
     require Data::ModeMerge::Config;
 
     my ($self, $args) = @_;
 
     if ($self->config) {
         my $is_hashref = ref($self->config) eq 'HASH';
         die "config must be a hashref or a Data::ModeMerge::Config" unless
             $is_hashref || UNIVERSAL::isa($self->config, "Data::ModeMerge::Config");
         $self->config(Data::ModeMerge::Config->new(%{ $self->config })) if $is_hashref;
     } else {
         $self->config(Data::ModeMerge::Config->new);
     }
 
     for (qw(NORMAL KEEP ADD CONCAT SUBTRACT DELETE)) {
 	$self->register_mode($_);
     }
 
     if (!$self->combine_rules) {
         $self->combine_rules({
             'ADD+ADD'            => ['ADD'     , 'ADD'   ],
             'ADD+DELETE'         => ['DELETE'  , 'DELETE'],
             'ADD+NORMAL'         => ['NORMAL'  , 'NORMAL'],
             'ADD+SUBTRACT'       => ['SUBTRACT', 'ADD'   ],
 
             'CONCAT+CONCAT'      => ['CONCAT'  , 'CONCAT'],
             'CONCAT+DELETE'      => ['DELETE'  , 'DELETE'],
             'CONCAT+NORMAL'      => ['NORMAL'  , 'NORMAL'],
 
             'DELETE+ADD'         => ['NORMAL'  , 'ADD'     ],
             'DELETE+CONCAT'      => ['NORMAL'  , 'CONCAT'  ],
             'DELETE+DELETE'      => ['DELETE'  , 'DELETE'  ],
             'DELETE+KEEP'        => ['NORMAL'  , 'KEEP'    ],
             'DELETE+NORMAL'      => ['NORMAL'  , 'NORMAL'  ],
             'DELETE+SUBTRACT'    => ['NORMAL'  , 'SUBTRACT'],
 
             'KEEP+ADD'          => ['KEEP', 'KEEP'],
             'KEEP+CONCAT'       => ['KEEP', 'KEEP'],
             'KEEP+DELETE'       => ['KEEP', 'KEEP'],
             'KEEP+KEEP'         => ['KEEP', 'KEEP'],
             'KEEP+NORMAL'       => ['KEEP', 'KEEP'],
             'KEEP+SUBTRACT'     => ['KEEP', 'KEEP'],
 
             'NORMAL+ADD'        => ['ADD'     , 'NORMAL'],
             'NORMAL+CONCAT'     => ['CONCAT'  , 'NORMAL'],
             'NORMAL+DELETE'     => ['DELETE'  , 'NORMAL'],
             'NORMAL+KEEP'       => ['NORMAL'  , 'KEEP'  ],
             'NORMAL+NORMAL'     => ['NORMAL'  , 'NORMAL'],
             'NORMAL+SUBTRACT'   => ['SUBTRACT', 'NORMAL'],
 
             'SUBTRACT+ADD'      => ['SUBTRACT', 'SUBTRACT'],
             'SUBTRACT+DELETE'   => ['DELETE'  , 'DELETE'  ],
             'SUBTRACT+NORMAL'   => ['NORMAL'  , 'NORMAL'  ],
             'SUBTRACT+SUBTRACT' => ['ADD'     , 'SUBTRACT'],
         });
     }
 }
 
 sub push_error {
     my ($self, $errmsg) = @_;
     push @{ $self->errors }, [[@{ $self->path }], $errmsg];
     return;
 }
 
 sub register_mode {
     my ($self, $name0) = @_;
     my $obj;
     if (ref($name0)) {
         my $obj = $name0;
     } elsif ($name0 =~ /^\w+(::\w+)+$/) {
         eval "require $name0; \$obj = $name0->new";
         die "Can't load module $name0: $@" if $@;
     } elsif ($name0 =~ /^\w+$/) {
         my $modname = "Data::ModeMerge::Mode::$name0";
         eval "require $modname; \$obj = $modname->new";
         die "Can't load module $modname: $@" if $@;
     } else {
         die "Invalid mode name $name0";
     }
     my $name = $obj->name;
     die "Mode $name already registered" if $self->modes->{$name};
     $obj->merger($self);
     $self->modes->{$name} = $obj;
 }
 
 sub check_prefix {
     my ($self, $hash_key) = @_;
     die "Hash key not a string" if ref($hash_key);
     my $dis = $self->config->disable_modes;
     if (defined($dis) && ref($dis) ne 'ARRAY') {
         $self->push_error("Invalid config value `disable_modes`: must be an array");
         return;
     }
     for my $mh (sort { $b->precedence_level <=> $a->precedence_level }
                 grep { !$dis || !$self->_in($_->name, $dis) }
                 values %{ $self->modes }) {
         if ($mh->check_prefix($hash_key)) {
             return $mh->name;
         }
     }
     return;
 }
 
 sub check_prefix_on_hash {
     my ($self, $hash) = @_;
     die "Not a hash" unless ref($hash) eq 'HASH';
     my $res = 0;
     for (keys %$hash) {
 	do { $res++; last } if $self->check_prefix($_);
     }
     $res;
 }
 
 sub add_prefix {
     my ($self, $hash_key, $mode) = @_;
     die "Hash key not a string" if ref($hash_key);
     my $dis = $self->config->disable_modes;
     if (defined($dis) && ref($dis) ne 'ARRAY') {
         die "Invalid config value `disable_modes`: must be an array";
     }
     if ($dis && $self->_in($mode, $dis)) {
         $self->push_error("Can't add prefix for currently disabled mode `$mode`");
         return $hash_key;
     }
     my $mh = $self->modes->{$mode} or die "Unknown mode: $mode";
     $mh->add_prefix($hash_key);
 }
 
 sub remove_prefix {
     my ($self, $hash_key) = @_;
     die "Hash key not a string" if ref($hash_key);
     my $dis = $self->config->disable_modes;
     if (defined($dis) && ref($dis) ne 'ARRAY') {
         die "Invalid config value `disable_modes`: must be an array";
     }
     for my $mh (sort { $b->precedence_level <=> $a->precedence_level }
                 grep { !$dis || !$self->_in($_->name, $dis) }
                 values %{ $self->modes }) {
         if ($mh->check_prefix($hash_key)) {
             my $r = $mh->remove_prefix($hash_key);
             if (wantarray) { return ($r, $mh->name) }
             else           { return $r }
         }
     }
     if (wantarray) { return ($hash_key, $self->config->default_mode) }
     else           { return $hash_key }
 }
 
 sub remove_prefix_on_hash {
     my ($self, $hash) = @_;
     die "Not a hash" unless ref($hash) eq 'HASH';
     for (keys %$hash) {
 	my $old = $_;
 	$_ = $self->remove_prefix($_);
 	next unless $old ne $_;
 	die "Conflict when removing prefix on hash: $old -> $_ but $_ already exists"
 	    if exists $hash->{$_};
 	$hash->{$_} = $hash->{$old};
 	delete $hash->{$old};
     }
     $hash;
 }
 
 sub merge {
     my ($self, $l, $r) = @_;
     $self->path([]);
     $self->errors([]);
     $self->mem({});
     $self->cur_mem_key(undef);
     my ($key, $res, $backup) = $self->_merge(undef, $l, $r);
     {
         success => !@{ $self->errors },
         error   => (@{ $self->errors } ?
                     join(", ",
                          map { sprintf("/%s: %s", join("/", @{ $_->[0] }), $_->[1]) }
                              @{ $self->errors }) : ''),
         result  => $res,
         backup  => $backup,
     };
 }
 
 sub _process_todo {
     my ($self) = @_;
     if ($self->cur_mem_key) {
         for my $mk (keys %{ $self->mem }) {
             my $res = $self->mem->{$mk}{res};
             if (defined($res) && @{ $self->mem->{$mk}{todo} }) {
                 for (@{  $self->mem->{$mk}{todo} }) {
                     $_->(@$res);
                     return if @{ $self->errors };
                 }
                 $self->mem->{$mk}{todo} = [];
             }
         }
     }
 }
 
 sub _merge {
     my ($self, $key, $l, $r, $mode) = @_;
     my $c = $self->config;
     $mode //= $c->default_mode;
 
     my $mh = $self->modes->{$mode};
     die "Can't find handler for mode $mode" unless $mh;
 
     my $rl = ref($l);
     my $rr = ref($r);
     my $tl = $rl eq 'HASH' ? 'HASH' : $rl eq 'ARRAY' ? 'ARRAY' : $rl eq 'CODE' ? 'CODE' : !$rl ? 'SCALAR' : '';
     my $tr = $rr eq 'HASH' ? 'HASH' : $rr eq 'ARRAY' ? 'ARRAY' : $rr eq 'CODE' ? 'CODE' : !$rr ? 'SCALAR' : '';
     if (!$tl) { $self->push_error("Unknown type in left side: $rl"); return }
     if (!$tr) { $self->push_error("Unknown type in right side: $rr"); return }
     if (!$c->allow_create_array && $tl ne 'ARRAY' && $tr eq 'ARRAY') {
         $self->push_error("Not allowed to create array"); return;
     }
     if (!$c->allow_create_hash && $tl ne 'HASH' && $tr eq 'HASH') {
         $self->push_error("Not allowed to create hash"); return;
     }
     if (!$c->allow_destroy_array && $tl eq 'ARRAY' && $tr ne 'ARRAY') {
         $self->push_error("Not allowed to destroy array"); return;
     }
     if (!$c->allow_destroy_hash && $tl eq 'HASH' && $tr ne 'HASH') {
         $self->push_error("Not allowed to destroy hash"); return;
     }
     my $meth = "merge_${tl}_${tr}";
     if (!$mh->can($meth)) { $self->push_error("No merge method found for $tl + $tr (mode $mode)"); return }
 
     my $memkey;
     if ($rl || $rr) {
         $memkey = sprintf "%s%s %s%s %s %s",
             (defined($l) ? ($rl ? 2 : 1) : 0),
             (defined($l) ? "$l" : ''),
             (defined($r) ? ($rr ? 2 : 1) : 0),
             (defined($r) ? "$r" : ''),
             $mode,
             $self->config;
     }
     if ($memkey) {
         if (exists $self->mem->{$memkey}) {
             $self->_process_todo;
             if (defined $self->mem->{$memkey}{res}) {
                 return @{ $self->mem->{$memkey}{res} };
             } else {
                 return ($key, undef, undef, 1);
             }
         } else {
             $self->mem->{$memkey} = {res=>undef, todo=>[]};
             $self->cur_mem_key($memkey);
             my ($newkey, $res, $backup) = $mh->$meth($key, $l, $r);
             $self->mem->{$memkey}{res} = [$newkey, $res, $backup];
             $self->_process_todo;
             return ($newkey, $res, $backup);
         }
     } else {
         $self->_process_todo;
         return $mh->$meth($key, $l, $r);
     }
 }
 
 sub _path_is_included {
     my ($self, $p1, $p2) = @_;
     my $res = 1;
     for my $i (0..@$p1-1) {
         do { $res = 0; last } if !defined($p2->[$i]) || $p1->[$i] ne $p2->[$i];
     }
     $res;
 }
 
 1;
 
 __END__
 
### Data/ModeMerge/Config.pm ###
 package Data::ModeMerge::Config;
 
 our $DATE = '2015-02-21'; 
 our $VERSION = '0.32'; 
 
 use 5.010;
 use Mo qw(build default);
 
 has recurse_hash          => (is => 'rw', default => sub{1});
 has recurse_array         => (is => 'rw', default => sub{0});
 has parse_prefix          => (is => 'rw', default => sub{1});
 has wanted_path           => (is => 'rw');
 has default_mode          => (is => 'rw', default => sub{'NORMAL'});
 has disable_modes         => (is => 'rw');
 has allow_create_array    => (is => 'rw', default => sub{1});
 has allow_create_hash     => (is => 'rw', default => sub{1});
 has allow_destroy_array   => (is => 'rw', default => sub{1});
 has allow_destroy_hash    => (is => 'rw', default => sub{1});
 has exclude_parse         => (is => 'rw');
 has exclude_parse_regex   => (is => 'rw');
 has include_parse         => (is => 'rw');
 has include_parse_regex   => (is => 'rw');
 has exclude_merge         => (is => 'rw');
 has exclude_merge_regex   => (is => 'rw');
 has include_merge         => (is => 'rw');
 has include_merge_regex   => (is => 'rw');
 has set_prefix            => (is => 'rw');
 has readd_prefix          => (is => 'rw', default => sub{1});
 has premerge_pair_filter  => (is => 'rw');
 has options_key           => (is => 'rw', default => sub{''});
 has allow_override        => (is => 'rw');
 has disallow_override     => (is => 'rw');
 
 sub _config_config {
     state $a = [qw/
         wanted_path
         options_key
         allow_override
         disallow_override
                   /];
 }
 
 sub _config_ok {
     state $a = [qw/
         recurse_hash
         recurse_array
         parse_prefix
         default_mode
         disable_modes
         allow_create_array
         allow_create_hash
         allow_destroy_array
         allow_destroy_hash
         exclude_parse
         exclude_parse_regex
         include_parse
         include_parse_regex
         exclude_merge
         exclude_merge_regex
         include_merge
         include_merge_regex
         set_prefix
         readd_prefix
         premerge_pair_filter
                   /];
 }
 
 1;
 
 __END__
 
### Data/ModeMerge/Mode/ADD.pm ###
 package Data::ModeMerge::Mode::ADD;
 
 our $DATE = '2015-02-21'; 
 our $VERSION = '0.32'; 
 
 use 5.010;
 use strict;
 use warnings;
 use Mo qw(build default);
 extends 'Data::ModeMerge::Mode::NORMAL';
 
 sub name { 'ADD' }
 
 sub precedence_level { 3 }
 
 sub default_prefix { '+' }
 
 sub default_prefix_re { qr/^\+/ }
 
 sub merge_SCALAR_SCALAR {
     my ($self, $key, $l, $r) = @_;
     ($key, ( $l // 0 ) + $r);
 }
 
 sub merge_SCALAR_ARRAY {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't add scalar and array");
     return;
 }
 
 sub merge_SCALAR_HASH {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't add scalar and hash");
     return;
 }
 
 sub merge_ARRAY_SCALAR {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't add array and scalar");
     return;
 }
 
 sub merge_ARRAY_ARRAY {
     my ($self, $key, $l, $r) = @_;
     ($key, [ @$l, @$r ]);
 }
 
 sub merge_ARRAY_HASH {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't add array and hash");
     return;
 }
 
 sub merge_HASH_SCALAR {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't add hash and scalar");
     return;
 }
 
 sub merge_HASH_ARRAY {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't add hash and array");
     return;
 }
 
 1;
 
 __END__
 
### Data/ModeMerge/Mode/Base.pm ###
 package Data::ModeMerge::Mode::Base;
 
 our $DATE = '2015-02-21'; 
 our $VERSION = '0.32'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 
 
 has merger => (is => 'rw');
 has prefix => (is => 'rw');
 has prefix_re => (is => 'rw');
 has check_prefix_sub => (is => 'rw');
 has add_prefix_sub => (is => 'rw');
 has remove_prefix_sub => (is => 'rw');
 
 sub name {
     die "Subclass must provide name()";
 }
 
 sub precedence_level {
     die "Subclass must provide precedence_level()";
 }
 
 sub default_prefix {
     die "Subclass must provide default_prefix()";
 }
 
 sub default_prefix_re {
     die "Subclass must provide default_prefix_re()";
 }
 
 sub BUILD {
     my ($self) = @_;
     $self->prefix($self->default_prefix);
     $self->prefix_re($self->default_prefix_re);
 }
 
 sub check_prefix {
     my ($self, $hash_key) = @_;
     if ($self->check_prefix_sub) {
         $self->check_prefix_sub->($hash_key);
     } else {
         $hash_key =~ $self->prefix_re;
     }
 }
 
 sub add_prefix {
     my ($self, $hash_key) = @_;
     if ($self->add_prefix_sub) {
         $self->add_prefix_sub->($hash_key);
     } else {
         $self->prefix . $hash_key;
     }
 }
 
 sub remove_prefix {
     my ($self, $hash_key) = @_;
     if ($self->remove_prefix_sub) {
         $self->remove_prefix_sub->($hash_key);
     } else {
         my $re = $self->prefix_re;
         $hash_key =~ s/$re//;
         $hash_key;
     }
 }
 
 sub merge_ARRAY_ARRAY {
     my ($self, $key, $l, $r) = @_;
     my $mm = $self->merger;
     my $c = $mm->config;
     return $self->merge_SCALAR_SCALAR($key, $l, $r) unless $c->recurse_array;
     return if $c->wanted_path && !$mm->_path_is_included($mm->path, $c->wanted_path);
 
     my @res;
     my @backup;
     my $la = @$l;
     my $lb = @$r;
     push @{ $mm->path }, -1;
     for my $i (0..($la > $lb ? $la : $lb)-1) {
         $mm->path->[-1] = $i;
         if ($i < $la && $i < $lb) {
             push @backup, $l->[$i];
             my ($subnewkey, $subres, $subbackup, $is_circular) = $mm->_merge($i, $l->[$i], $r->[$i], $c->default_mode);
             last if @{ $mm->errors };
             if ($is_circular) {
                 push @res, undef;
                 push @{ $mm->mem->{ $mm->cur_mem_key }{todo} }, sub {
                     my ($subnewkey, $subres, $subbackup) = @_;
                     $res[$i] = $subres;
                 }
             } else {
                 push @res, $subres;
             }
         } elsif ($i < $la) {
             push @res, $l->[$i];
         } else {
             push @res, $r->[$i];
         }
     }
     pop @{ $mm->path };
     ($key, \@res, \@backup);
 }
 
 sub _prefilter_hash {
     my ($self, $h, $desc, $sub) = @_;
     my $mm = $self->merger;
 
     if (ref($sub) ne 'CODE') {
         $mm->push_error("$desc failed: filter must be a coderef");
         return;
     }
 
     my $res = {};
     for (keys %$h) {
         my @r = $sub->($_, $h->{$_});
         while (my ($k, $v) = splice @r, 0, 2) {
             next unless defined $k;
             if (exists $res->{$k}) {
                 $mm->push_error("$desc failed; key conflict: ".
                                 "$_ -> $k, but key $k already exists");
                 return;
             }
             $res->{$k} = $v;
         }
     }
 
     $res;
 }
 
 sub _gen_left {
     my ($self, $l, $mode, $esub, $ep, $ip, $epr, $ipr) = @_;
     my $mm = $self->merger;
     my $c = $mm->config;
 
 
     if ($c->premerge_pair_filter) {
         $l = $self->_prefilter_hash($l, "premerge filter left hash",
                                     $c->premerge_pair_filter);
         return if @{ $mm->errors };
     }
 
     my $hl = {};
     if ($c->parse_prefix) {
         for (keys %$l) {
             my $do_parse = 1;
             $do_parse = 0 if $do_parse && $ep  &&  $mm->_in($_, $ep);
             $do_parse = 0 if $do_parse && $ip  && !$mm->_in($_, $ip);
             $do_parse = 0 if $do_parse && $epr &&  /$epr/;
             $do_parse = 0 if $do_parse && $ipr && !/$ipr/;
 
             if ($do_parse) {
                 my $old = $_;
                 my $m2;
                 ($_, $m2) = $mm->remove_prefix($_);
                 next if $esub && !$esub->($_);
                 if ($old ne $_ && exists($l->{$_})) {
                     $mm->push_error("Conflict when removing prefix on left-side ".
                                     "hash key: $old -> $_ but $_ already exists");
                     return;
                 }
                 $hl->{$_} = [$m2, $l->{$old}];
             } else {
                 next if $esub && !$esub->($_);
                 $hl->{$_} = [$mode, $l->{$_}];
             }
         }
     } else {
         for (keys %$l) {
             next if $esub && !$esub->($_);
             $hl->{$_} = [$mode, $l->{$_}];
         }
     }
 
     $hl;
 }
 
 sub _gen_right {
     my ($self, $r, $mode, $esub, $ep, $ip, $epr, $ipr) = @_;
     my $mm = $self->merger;
     my $c = $mm->config;
 
 
     if ($c->premerge_pair_filter) {
         $r = $self->_prefilter_hash($r, "premerge filter right hash",
                                     $c->premerge_pair_filter);
         return if @{ $mm->errors };
     }
 
     my $hr = {};
     if ($c->parse_prefix) {
         for (keys %$r) {
             my $do_parse = 1;
             $do_parse = 0 if $do_parse && $ep  &&  $mm->_in($_, $ep);
             $do_parse = 0 if $do_parse && $ip  && !$mm->_in($_, $ip);
             $do_parse = 0 if $do_parse && $epr &&  /$epr/;
             $do_parse = 0 if $do_parse && $ipr && !/$ipr/;
 
             if ($do_parse) {
                 my $old = $_;
                 my $m2;
                 ($_, $m2) = $mm->remove_prefix($_);
                 next if $esub && !$esub->($_);
                 if (exists $hr->{$_}{$m2}) {
                     $mm->push_error("Conflict when removing prefix on right-side ".
                                     "hash key: $old($m2) -> $_ ($m2) but $_ ($m2) ".
                                     "already exists");
                     return;
                 }
                 $hr->{$_}{$m2} = $r->{$old};
             } else {
                 next if $esub && !$esub->($_);
                 $hr->{$_} = {$mode => $r->{$_}};
             }
         }
     } else {
         for (keys %$r) {
             next if $esub && !$esub->($_);
             $hr->{$_} = {$mode => $r->{$_}}
         }
     }
     $hr;
 }
 
 sub _merge_gen {
     my ($self, $hl, $hr, $mode, $em, $im, $emr, $imr) = @_;
     my $mm = $self->merger;
     my $c = $mm->config;
 
 
     my $res = {};
     my $backup = {};
 
     my %k = map {$_=>1} keys(%$hl), keys(%$hr);
     push @{ $mm->path }, "";
   K:
     for my $k (keys %k) {
         my @o;
         $mm->path->[-1] = $k;
         my $do_merge = 1;
         $do_merge = 0 if $do_merge && $em  &&  $mm->_in($k, $em);
         $do_merge = 0 if $do_merge && $im  && !$mm->_in($k, $im);
         $do_merge = 0 if $do_merge && $emr && $k =~ /$emr/;
         $do_merge = 0 if $do_merge && $imr && $k !~ /$imr/;
 
         if (!$do_merge) {
             $res->{$k} = $hl->{$k} if $hl->{$k};
             next K;
         }
 
         $backup->{$k} = $hl->{$k}[1] if $hl->{$k} && $hr->{$k};
         if ($hl->{$k}) {
             push @o, $hl->{$k};
         }
         if ($hr->{$k}) {
             my %m = map {$_=>$mm->modes->{$_}->precedence_level} keys %{ $hr->{$k} };
             push @o, map { [$_, $hr->{$k}{$_}] } sort { $m{$b} <=> $m{$a} } keys %m;
         }
         my $final_mode;
         my $is_circular;
         my $v;
         for my $i (0..$#o) {
             if ($i == 0) {
                 my $mh = $mm->modes->{$o[$i][0]};
                 if (@o == 1 &&
                         (($hl->{$k} && $mh->can("merge_left_only")) ||
                          ($hr->{$k} && $mh->can("merge_right_only")))) {
                     my $meth = $hl->{$k} ? "merge_left_only" : "merge_right_only";
                     my ($subnewkey, $v, $subbackup, $is_circular, $newmode) = $mh->$meth($k, $o[$i][1]); 
                     next K unless defined($subnewkey);
                     $final_mode = $newmode;
                     $v = $res;
                 } else {
                     $final_mode = $o[$i][0];
                     $v = $o[$i][1];
                 }
             } else {
                 my $m = $mm->combine_rules->{"$final_mode+$o[$i][0]"}
                     or do {
                         $mm->push_error("Can't merge $final_mode + $o[$i][0]");
                         return;
                     };
                 my ($subnewkey, $subbackup);
                 ($subnewkey, $v, $subbackup, $is_circular) = $mm->_merge($k, $v, $o[$i][1], $m->[0]);
                 return if @{ $mm->errors };
                 if ($is_circular) {
                     if ($i < $#o) {
                         $mm->push_error("Can't handle circular at $i of $#o merges (mode $m->[0]): not the last merge");
                         return;
                     }
                     push @{ $mm->mem->{ $mm->cur_mem_key }{todo} }, sub {
                         my ($subnewkey, $subres, $subbackup) = @_;
                         my $final_mode = $m->[1];
                         $res->{$k} = [$m->[1], $subres];
                         if ($c->readd_prefix) {
                             $self->_readd_prefix($res, $k, $c->default_mode);
                         } else {
                             $res->{$k} = $res->{$k}[1];
                         }
                     };
                     delete $res->{$k};
                 }
                 next K unless defined $subnewkey;
                 $final_mode = $m->[1];
             }
         }
         $res->{$k} = [$final_mode, $v] unless $is_circular;
     }
     pop @{ $mm->path };
     ($res, $backup);
 }
 
 sub _readd_prefix {
     my ($self, $hh, $k, $defmode) = @_;
     my $mm = $self->merger;
     my $c = $mm->config;
 
     my $m = $hh->{$k}[0];
     if ($m eq $defmode) {
         $hh->{$k} = $hh->{$k}[1];
     } else {
         my $kp = $mm->modes->{$m}->add_prefix($k);
         if (exists $hh->{$kp}) {
             $mm->push_error("BUG: conflict when re-adding prefix after merge: $kp");
             return;
         }
         $hh->{$kp} = $hh->{$k}[1];
         delete $hh->{$k};
     }
 }
 
 sub merge_HASH_HASH {
     my ($self, $key, $l, $r, $mode) = @_;
     my $mm = $self->merger;
     my $c = $mm->config;
     $mode //= $c->default_mode;
 
     return $self->merge_SCALAR_SCALAR($key, $l, $r) unless $c->recurse_hash;
     return if $c->wanted_path && !$mm->_path_is_included($mm->path, $c->wanted_path);
 
     my $config_replaced;
     my $orig_c = $c;
     my $ok = $c->options_key;
     {
         last unless defined $ok;
 
         my $okl = $self->_gen_left ($l, $mode, sub {$_[0] eq $ok});
         return if @{ $mm->errors };
 
         my $okr = $self->_gen_right($r, $mode, sub {$_[0] eq $ok});
         return if @{ $mm->errors };
 
         push @{ $mm->path }, $ok;
         my ($res, $backup);
         {
             local $c->{readd_prefix} = 0;
             ($res, $backup) = $self->_merge_gen($okl, $okr, $mode);
         }
         pop @{ $mm->path };
         return if @{ $mm->errors };
 
 
         $res = $res->{$ok} ? $res->{$ok}[1] : undef;
         if (defined($res) && ref($res) ne 'HASH') {
             $mm->push_error("Invalid options key after merge: value must be hash");
             return;
         }
         last unless keys %$res;
         my $c2 = bless({ %$c }, ref($c));
 
         for (keys %$res) {
             if ($c->allow_override) {
                 my $re = $c->allow_override;
                 if (!/$re/) {
                     $mm->push_error("Configuration in options key `$_` not allowed by allow_override $re");
                     return;
                 }
             }
             if ($c->disallow_override) {
                 my $re = $c->disallow_override;
                 if (/$re/) {
                     $mm->push_error("Configuration in options key `$_` not allowed by disallow_override $re");
                     return;
                 }
             }
             if ($mm->_in($_, $c->_config_config)) {
                 $mm->push_error("Configuration not allowed in options key: $_");
                 return;
             }
             if ($_ ne $ok && !$mm->_in($_, $c->_config_ok)) {
                 $mm->push_error("Unknown configuration in options key: $_");
                 return;
             }
             $c2->$_($res->{$_}) unless $_ eq $ok;
         }
         $mm->config($c2);
         $config_replaced++;
         $c = $c2;
     }
 
     my $sp = $c->set_prefix;
     my $saved_prefixes;
     if (defined($sp)) {
         if (ref($sp) ne 'HASH') {
             $mm->push_error("Invalid config value `set_prefix`: must be a hash");
             return;
         }
         $saved_prefixes = {};
         for my $mh (values %{ $mm->modes }) {
             my $n = $mh->name;
             if ($sp->{$n}) {
                 $saved_prefixes->{$n} = {
                     prefix => $mh->prefix,
                     prefix_re => $mh->prefix_re,
                     check_prefix_sub => $mh->check_prefix_sub,
                     add_prefix_sub => $mh->add_prefix_sub,
                     remove_prefix_sub => $mh->remove_prefix_sub,
                 };
                 $mh->prefix($sp->{$n});
                 my $re = quotemeta($sp->{$n});
                 $mh->prefix_re(qr/^$re/);
                 $mh->check_prefix_sub(undef);
                 $mh->add_prefix_sub(undef);
                 $mh->remove_prefix_sub(undef);
             }
         }
     }
 
     my $ep = $c->exclude_parse;
     my $ip = $c->include_parse;
     if (defined($ep) && ref($ep) ne 'ARRAY') {
         $mm->push_error("Invalid config value `exclude_parse`: must be an array");
         return;
     }
     if (defined($ip) && ref($ip) ne 'ARRAY') {
         $mm->push_error("Invalid config value `include_parse`: must be an array");
         return;
     }
 
     my $epr = $c->exclude_parse_regex;
     my $ipr = $c->include_parse_regex;
     if (defined($epr)) {
         eval { $epr = qr/$epr/ };
         if ($@) {
             $mm->push_error("Invalid config value `exclude_parse_regex`: invalid regex: $@");
             return;
         }
     }
     if (defined($ipr)) {
         eval { $ipr = qr/$ipr/ };
         if ($@) {
             $mm->push_error("Invalid config value `include_parse_regex`: invalid regex: $@");
             return;
         }
     }
 
     my $hl = $self->_gen_left ($l, $mode, sub {defined($ok) ? $_[0] ne $ok : 1}, $ep, $ip, $epr, $ipr);
     return if @{ $mm->errors };
 
     my $hr = $self->_gen_right($r, $mode, sub {defined($ok) ? $_[0] ne $ok : 1}, $ep, $ip, $epr, $ipr);
     return if @{ $mm->errors };
 
 
     my $em = $c->exclude_merge;
     my $im = $c->include_merge;
     if (defined($em) && ref($em) ne 'ARRAY') {
         $mm->push_error("Invalid config value `exclude_marge`: must be an array");
         return;
     }
     if (defined($im) && ref($im) ne 'ARRAY') {
         $mm->push_error("Invalid config value `include_merge`: must be an array");
         return;
     }
 
     my $emr = $c->exclude_merge_regex;
     my $imr = $c->include_merge_regex;
     if (defined($emr)) {
         eval { $emr = qr/$emr/ };
         if ($@) {
             $mm->push_error("Invalid config value `exclude_merge_regex`: invalid regex: $@");
             return;
         }
     }
     if (defined($imr)) {
         eval { $imr = qr/$imr/ };
         if ($@) {
             $mm->push_error("Invalid config value `include_merge_regex`: invalid regex: $@");
             return;
         }
     }
 
     my ($res, $backup) = $self->_merge_gen($hl, $hr, $mode, $em, $im, $emr, $imr);
     return if @{ $mm->errors };
 
 
     if ($c->readd_prefix) {
         for my $k (keys %$res) {
             $self->_readd_prefix($res, $k, $c->default_mode);
         }
     } else {
         $res->{$_} = $res->{$_}[1] for keys %$res;
     }
 
     if ($saved_prefixes) {
         for (keys %$saved_prefixes) {
             my $mh = $mm->modes->{$_};
             my $s = $saved_prefixes->{$_};
             $mh->prefix($s->{prefix});
             $mh->prefix_re($s->{prefix_re});
             $mh->check_prefix_sub($s->{check_prefix_sub});
             $mh->add_prefix_sub($s->{add_prefix_sub});
             $mh->remove_prefix_sub($s->{remove_prefix_sub});
         }
     }
 
     if ($config_replaced) {
         $mm->config($orig_c);
     }
 
     ($key, $res, $backup);
 }
 
 1;
 
 __END__
 
### Data/ModeMerge/Mode/CONCAT.pm ###
 package Data::ModeMerge::Mode::CONCAT;
 
 our $DATE = '2015-02-21'; 
 our $VERSION = '0.32'; 
 
 use 5.010;
 use strict;
 use warnings;
 use Mo qw(build default);
 extends 'Data::ModeMerge::Mode::ADD';
 
 sub name { 'CONCAT' }
 
 sub precedence_level { 2 }
 
 sub default_prefix { '.' }
 
 sub default_prefix_re { qr/^\./ }
 
 sub merge_SCALAR_SCALAR {
     my ($self, $key, $l, $r) = @_;
     ($key, ($l // "") . $r);
 }
 
 1;
 
 __END__
 
### Data/ModeMerge/Mode/DELETE.pm ###
 package Data::ModeMerge::Mode::DELETE;
 
 our $DATE = '2015-02-21'; 
 our $VERSION = '0.32'; 
 
 use 5.010;
 use strict;
 use warnings;
 use Mo qw(build default);
 extends 'Data::ModeMerge::Mode::Base';
 
 sub name { 'DELETE' }
 
 sub precedence_level { 1 }
 
 sub default_prefix { '!' }
 
 sub default_prefix_re { qr/^!/ }
 
 sub merge_left_only {
     my ($self, $key, $l) = @_;
     return;
 }
 
 sub merge_right_only {
     my ($self, $key, $r) = @_;
     return;
 }
 
 sub merge_SCALAR_SCALAR {
     return;
 }
 
 sub merge_SCALAR_ARRAY {
     return;
 }
 
 sub merge_SCALAR_HASH {
     return;
 }
 
 sub merge_ARRAY_SCALAR {
     return;
 }
 
 sub merge_ARRAY_ARRAY {
     my ($self, $key, $l, $r) = @_;
     $self->merger->config->allow_destroy_array or
         $self->merger->push_error("Now allowed to destroy array via DELETE mode");
     return;
 }
 
 sub merge_ARRAY_HASH {
     return;
 }
 
 sub merge_HASH_SCALAR {
     return;
 }
 
 sub merge_HASH_ARRAY {
     return;
 }
 
 sub merge_HASH_HASH {
     my ($self, $key, $l, $r) = @_;
     $self->merger->config->allow_destroy_hash or
         $self->merger->push_error("Now allowed to destroy hash via DELETE mode");
     return;
 }
 
 1;
 
 __END__
 
### Data/ModeMerge/Mode/KEEP.pm ###
 package Data::ModeMerge::Mode::KEEP;
 
 our $DATE = '2015-02-21'; 
 our $VERSION = '0.32'; 
 
 use 5.010;
 use strict;
 use warnings;
 use Mo qw(build default);
 extends 'Data::ModeMerge::Mode::Base';
 
 sub name { 'KEEP' }
 
 sub precedence_level { 6 }
 
 sub default_prefix { '^' }
 
 sub default_prefix_re { qr/^\^/ }
 
 sub merge_SCALAR_SCALAR {
     my ($self, $key, $l, $r) = @_;
     ($key, $l);
 }
 
 sub merge_SCALAR_ARRAY {
     my ($self, $key, $l, $r) = @_;
     ($key, $l);
 }
 
 sub merge_SCALAR_HASH {
     my ($self, $key, $l, $r) = @_;
     ($key, $l);
 }
 
 sub merge_ARRAY_SCALAR {
     my ($self, $key, $l, $r) = @_;
     ($key, $l);
 }
 
 sub merge_ARRAY_ARRAY {
     my ($self, $key, $l, $r) = @_;
     $self->SUPER::merge_ARRAY_ARRAY($key, $l, $r, 'KEEP');
 };
 
 sub merge_ARRAY_HASH {
     my ($self, $key, $l, $r) = @_;
     ($key, $l);
 }
 
 sub merge_HASH_SCALAR {
     my ($self, $key, $l, $r) = @_;
     ($key, $l);
 }
 
 sub merge_HASH_ARRAY {
     my ($self, $key, $l, $r) = @_;
     ($key, $l);
 }
 
 sub merge_HASH_HASH {
     my ($self, $key, $l, $r) = @_;
     $self->SUPER::merge_HASH_HASH($key, $l, $r, 'KEEP');
 };
 
 1;
 
 __END__
 
### Data/ModeMerge/Mode/NORMAL.pm ###
 package Data::ModeMerge::Mode::NORMAL;
 
 our $DATE = '2015-02-21'; 
 our $VERSION = '0.32'; 
 
 use 5.010;
 use strict;
 use warnings;
 use Mo qw(build default);
 extends 'Data::ModeMerge::Mode::Base';
 
 sub name { 'NORMAL' }
 
 sub precedence_level { 5 }
 
 sub default_prefix { '*' }
 
 sub default_prefix_re { qr/^\*/ }
 
 sub merge_SCALAR_SCALAR {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_SCALAR_ARRAY {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_SCALAR_HASH {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_SCALAR_CODE {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_ARRAY_SCALAR {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_ARRAY_HASH {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_ARRAY_CODE {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_HASH_SCALAR {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_HASH_ARRAY {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_HASH_CODE {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_CODE_SCALAR {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_CODE_ARRAY {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_CODE_HASH {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 sub merge_CODE_CODE {
     my ($self, $key, $l, $r) = @_;
     ($key, $r);
 }
 
 1;
 
 __END__
 
### Data/ModeMerge/Mode/SUBTRACT.pm ###
 package Data::ModeMerge::Mode::SUBTRACT;
 
 our $DATE = '2015-02-21'; 
 our $VERSION = '0.32'; 
 
 use 5.010;
 use strict;
 use warnings;
 use Mo qw(build default);
 extends 'Data::ModeMerge::Mode::NORMAL';
 
 sub name { 'SUBTRACT' }
 
 sub precedence_level { 4 }
 
 sub default_prefix { '-' }
 
 sub default_prefix_re { qr/^-/ }
 
 sub merge_SCALAR_SCALAR {
     my ($self, $key, $l, $r) = @_;
     ($key, $l - $r);
 }
 
 sub merge_SCALAR_ARRAY {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't subtract scalar and array");
     return;
 }
 
 sub merge_SCALAR_HASH {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't subtract scalar and hash");
     return;
 }
 
 sub merge_ARRAY_SCALAR {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't subtract array and scalar");
     return;
 }
 
 sub merge_ARRAY_ARRAY {
     my ($self, $key, $l, $r) = @_;
     my @res;
     my $mm = $self->merger;
     for (@$l) {
         push @res, $_ unless $mm->_in($_, $r);
     }
     ($key, \@res);
 }
 
 sub merge_ARRAY_HASH {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't subtract array and hash");
     return;
 }
 
 sub merge_HASH_SCALAR {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't subtract hash and scalar");
     return;
 }
 
 sub merge_HASH_ARRAY {
     my ($self, $key, $l, $r) = @_;
     $self->merger->push_error("Can't subtract hash and array");
     return;
 }
 
 sub merge_HASH_HASH {
     my ($self, $key, $l, $r) = @_;
     my $mm = $self->merger;
 
     my %res;
     my $r2 = {};
     for (keys %$r) {
         my $k = $mm->check_prefix($_) ? $_ : $mm->add_prefix($_, 'DELETE');
         if ($k ne $_ && exists($r->{$k})) {
             $mm->push_error("Conflict when adding DELETE prefix on right-side hash key $_ ".
                             "for SUBTRACT merge: key $k already exists");
             return;
         }
         $r2->{$k} = $r->{$_};
     }
     $mm->_merge($key, $l, $r2, 'NORMAL');
 }
 
 1;
 
 __END__
 
### Data/Sah.pm ###
 package Data::Sah;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 
 our $Log_Validator_Code = $ENV{LOG_SAH_VALIDATOR_CODE} // 0;
 
 use Data::Sah::Normalize qw(
                        $type_re
                        $clause_name_re
                        $clause_re
                        $attr_re
                        $funcset_re
                        $compiler_re
                        );
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(normalize_schema gen_validator);
 
 has compilers    => (is => 'rw', default => sub { {} });
 
 has _merger      => (
     is      => 'rw',
     lazy    => 1,
     default => sub {
         require Data::ModeMerge;
         my $mm = Data::ModeMerge->new(config => {
             recurse_array => 1,
         });
         $mm->modes->{NORMAL}  ->prefix   ('merge.normal.');
         $mm->modes->{NORMAL}  ->prefix_re(qr/\Amerge\.normal\./);
         $mm->modes->{ADD}     ->prefix   ('merge.add.');
         $mm->modes->{ADD}     ->prefix_re(qr/\Amerge\.add\./);
         $mm->modes->{CONCAT}  ->prefix   ('merge.concat.');
         $mm->modes->{CONCAT}  ->prefix_re(qr/\Amerge\.concat\./);
         $mm->modes->{SUBTRACT}->prefix   ('merge.subtract.');
         $mm->modes->{SUBTRACT}->prefix_re(qr/\Amerge\.subtract\./);
         $mm->modes->{DELETE}  ->prefix   ('merge.delete.');
         $mm->modes->{DELETE}  ->prefix_re(qr/\Amerge\.delete\./);
         $mm->modes->{KEEP}    ->prefix   ('merge.keep.');
         $mm->modes->{KEEP}    ->prefix_re(qr/\Amerge\.keep\./);
         $mm;
     },
 );
 
 has _var_enumer  => (
     is      => 'rw',
     lazy    => 1,
     default => sub {
         require Language::Expr::Interpreter::VarEnumer;
         Language::Expr::Interpreter::VarEnumer->new;
     },
 );
 
 sub normalize_clset {
     require Scalar::Util;
 
     my $self;
     if (Scalar::Util::blessed($_[0])) {
         $self = shift;
     } else {
         $self = __PACKAGE__->new;
     }
 
     Data::Sah::Normalize::normalize_clset($_[0]);
 }
 
 sub normalize_schema {
     require Scalar::Util;
 
     my $self;
     if (Scalar::Util::blessed($_[0])) {
         $self = shift;
     } else {
         $self = __PACKAGE__->new;
     }
     my ($s) = @_;
 
     Data::Sah::Normalize::normalize_schema($_[0]);
 }
 
 sub gen_validator {
     require Scalar::Util;
 
     my $self;
     if (Scalar::Util::blessed($_[0])) {
         $self = shift;
     } else {
         $self = __PACKAGE__->new;
     }
     my ($schema, $opts) = @_;
     my %args = (schema => $schema, %{$opts // {}});
     my $opt_source = delete $args{source};
 
     $args{log_result} = 1 if $Log_Validator_Code;
 
     my $pl = $self->get_compiler("perl");
     my $code = $pl->expr_validator_sub(%args);
     return $code if $opt_source;
 
     my $res = eval $code;
     die "Can't compile validator: $@" if $@;
     $res;
 }
 
 sub _merge_clause_sets {
     my ($self, @clause_sets) = @_;
     my @merged;
 
     my $mm = $self->_merger;
 
     my @c;
     for (@clause_sets) {
         push @c, {cs=>$_, has_prefix=>$mm->check_prefix_on_hash($_)};
     }
     for (reverse @c) {
         if ($_->{has_prefix}) { $_->{last_with_prefix} = 1; last }
     }
 
     my $i = -1;
     for my $c (@c) {
         $i++;
         if (!$i || !$c->{has_prefix} && !$c[$i-1]{has_prefix}) {
             push @merged, $c->{cs};
             next;
         }
         $mm->config->readd_prefix(
             ($c->{last_with_prefix} || $c[$i-1]{last_with_prefix}) ? 0 : 1);
         my $mres = $mm->merge($merged[-1], $c->{cs});
         die "Can't merge clause sets: $mres->{error}" unless $mres->{success};
         $merged[-1] = $mres->{result};
     }
     \@merged;
 }
 
 sub get_compiler {
     my ($self, $name) = @_;
     return $self->compilers->{$name} if $self->compilers->{$name};
 
     die "Invalid compiler name `$name`" unless $name =~ $compiler_re;
     my $module = "Data::Sah::Compiler::$name";
     if (!eval "require $module; 1") {
         die "Can't load compiler module $module".($@ ? ": $@" : "");
     }
 
     my $obj = $module->new(main => $self);
     $self->compilers->{$name} = $obj;
 
     return $obj;
 }
 
 sub normalize_var {
     my ($self, $var, $curpath) = @_;
     die "Not yet implemented";
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler.pm ###
 package Data::Sah::Compiler;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(default);
 use Role::Tiny::With;
 use Log::Any::IfLOG qw($log);
 
 with 'Data::Sah::Compiler::TextResultRole';
 
 use Scalar::Util qw(blessed);
 
 has main => (is => 'rw');
 
 has expr_compiler => (
     is => 'rw',
     lazy => 1,
     default => sub {
         require Language::Expr;
         Language::Expr->new;
     },
 );
 
 sub name {
     die "BUG: Please override name()";
 }
 
 sub literal {
     die "BUG: Please override literal()";
 }
 
 sub expr {
     die "BUG: Please override expr()";
 }
 
 sub _die {
     my ($self, $cd, $msg) = @_;
     die join(
         "",
         "Sah ". $self->name . " compiler: ",
         "at schema:/", join("/", @{$cd->{spath} // []}), ": ",
         $msg,
     );
 }
 
 sub _form_deps {
     require Algorithm::Dependency::Ordered;
     require Algorithm::Dependency::Source::HoA;
     require Language::Expr::Interpreter::VarEnumer;
 
     my ($self, $cd, $ctbl) = @_;
     my $main = $self->main;
 
     my %depends;
     for my $crec (values %$ctbl) {
         my $cn = $crec->{name};
         my $expr = defined($crec->{expr}) ? $crec->{value} :
             $crec->{attrs}{expr};
         if (defined $expr) {
             my $vars = $main->_var_enumer->eval($expr);
             for (@$vars) {
                 /^\w+$/ or $self->_die($cd,
                     "Invalid variable syntax '$_', ".
                         "currently only the form \$abc is supported");
                 $ctbl->{$_} or $self->_die($cd,
                     "Unhandled clause specified in variable '$_'");
             }
             $depends{$cn} = $vars;
             for (@$vars) {
                 push @{ $ctbl->{$_}{depended_by} }, $cn;
             }
         } else {
             $depends{$cn} = [];
         }
     }
     my $ds = Algorithm::Dependency::Source::HoA->new(\%depends);
     my $ad = Algorithm::Dependency::Ordered->new(source => $ds)
         or die "Failed to set up dependency algorithm";
     my $sched = $ad->schedule_all
         or die "Can't resolve dependencies, please check your expressions";
     my %rsched = map
         {@{ $depends{$sched->[$_]} } ? ($sched->[$_] => $_) : ()}
             0..@$sched-1;
     \%rsched;
 }
 
 sub _resolve_base_type {
     require Scalar::Util;
 
     my ($self, %args) = @_;
     my $ns   = $args{schema};
     my $t    = $ns->[0];
     my $cd   = $args{cd};
     my $th   = $self->get_th(name=>$t, cd=>$cd);
     my $seen = $args{seen} // {};
     my $res  = $args{res} // [$t, [], []];
 
     $self->_die($cd, "Recursive dependency on type '$t'") if $seen->{$t}++;
 
     $res->[0] = $t;
     unshift @{$res->[1]}, $ns->[1] if keys(%{$ns->[1]});
     unshift @{$res->[2]}, $ns->[2] if $ns->[2];
     if (Scalar::Util::blessed $th) {
         $res->[1] = $self->main->_merge_clause_sets(@{$res->[1]}) if @{$res->[1]} > 1;
         $res->[2] = $self->main->_merge_clause_sets(@{$res->[2]}) if @{$res->[2]} > 1;
     } else {
         $self->_resolve_base_type(schema=>$th, cd=>$cd, seen=>$seen, res=>$res);
     }
     $res;
 }
 
 sub _get_clauses_from_clsets {
     my ($self, $cd, $clsets) = @_;
     my $tn = $cd->{type};
     my $th = $cd->{th};
 
     my $deps;
 
     my $sorter = sub {
         my ($ia, $ca, $metaa) = @$a;
         my ($ib, $cb, $metab) = @$b;
         my $res;
 
 
         {
             $res = $metaa->{prio} <=> $metab->{prio};
             last if $res;
 
             my $sprioa = $clsets->[$ia]{"$ca.prio"} // 50;
             my $spriob = $clsets->[$ib]{"$cb.prio"} // 50;
             $res = $sprioa <=> $spriob;
             last if $res;
 
             $res = $ca cmp $cb;
             last if $res;
 
             $res = $ia <=> $ib;
             last if $res;
 
             $res = 0;
         }
 
         $res;
     };
 
     my @clauses;
     for my $i (0..@$clsets-1) {
         for my $k (grep {!/\A_/ && !/\./} keys %{$clsets->[$i]}) {
             my $meta;
             eval {
                 $meta = "Data::Sah::Type::$tn"->${\("clausemeta_$k")};
             };
             if ($@) {
                 for ($cd->{args}{on_unhandled_clause}) {
                     my $msg = "Unhandled clause for type $tn: $k ($@)";
                     next if $_ eq 'ignore';
                     next if $_ eq 'warn'; 
                     $self->_die($cd, $msg);
                 }
             }
             $meta //= {prio=>50};
             push @clauses, [$i, $k, $meta];
         }
     }
 
     my $res = [sort $sorter @clauses];
     $res;
 }
 
 sub get_th {
     my ($self, %args) = @_;
     my $cd    = $args{cd};
     my $name  = $args{name};
 
     my $th_map = $cd->{th_map};
     return $th_map->{$name} if $th_map->{$name};
 
     if ($args{load} // 1) {
         no warnings;
         $self->_die($cd, "Invalid syntax for type name '$name', please use ".
                         "letters/numbers/underscores only")
             unless $name =~ $Data::Sah::type_re;
         my $main = $self->main;
         my $module = ref($self) . "::TH::$name";
         if (!eval "require $module; 1") {
             $self->_die($cd, "Can't load type handler $module".
                             ($@ ? ": $@" : ""));
         }
 
         my $obj = $module->new(compiler=>$self);
         $th_map->{$name} = $obj;
     }
     use experimental 'smartmatch';
 
     return $th_map->{$name};
 }
 
 sub get_fsh {
     my ($self, %args) = @_;
     my $cd    = $args{cd};
     my $name  = $args{name};
 
     my $fsh_table = $cd->{fsh_table};
     return $fsh_table->{$name} if $fsh_table->{$name};
 
     if ($args{load} // 1) {
         no warnings;
         $self->_die($cd, "Invalid syntax for func set name '$name', ".
                         "please use letters/numbers/underscores")
             unless $name =~ $Data::Sah::funcset_re;
         my $module = ref($self) . "::FSH::$name";
         if (!eval "require $module; 1") {
             $self->_die($cd, "Can't load func set handler $module".
                             ($@ ? ": $@" : ""));
         }
 
         my $obj = $module->new();
         $fsh_table->{$name} = $obj;
     }
     use experimental 'smartmatch';
 
     return $fsh_table->{$name};
 }
 
 sub init_cd {
     require Time::HiRes;
 
     my ($self, %args) = @_;
 
     my $cd = {};
     $cd->{args} = \%args;
 
     if (my $ocd = $args{outer_cd}) {
         $cd->{_inner}       = 1;
 
         $cd->{outer_cd}     = $ocd;
         $cd->{indent_level} = $ocd->{indent_level};
         $cd->{th_map}       = { %{ $ocd->{th_map}  } };
         $cd->{fsh_map}      = { %{ $ocd->{fsh_map} } };
         $cd->{default_lang} = $ocd->{default_lang};
         $cd->{spath}        = [@{ $ocd->{spath} }];
     } else {
         $cd->{indent_level} = $cd->{args}{indent_level} // 0;
         $cd->{th_map}       = {};
         $cd->{fsh_map}      = {};
         $cd->{default_lang} = $ENV{LANG} || "en_US";
         $cd->{default_lang} =~ s/\..+//; 
         $cd->{spath}        = [];
     }
     $cd->{_id} = Time::HiRes::gettimeofday(); 
     $cd->{ccls} = [];
 
     $cd;
 }
 
 sub check_compile_args {
     my ($self, $args) = @_;
 
     return if $args->{_args_checked}++;
 
     $args->{data_name} //= 'data';
     $args->{data_name} =~ /\A[A-Za-z_]\w*\z/ or $self->_die(
         {}, "Invalid syntax in data_name '$args->{data_name}', ".
             "please use letters/nums only");
     $args->{allow_expr} //= 1;
     $args->{on_unhandled_attr}   //= 'die';
     $args->{on_unhandled_clause} //= 'die';
     $args->{skip_clause}         //= [];
     $args->{mark_missing_translation} //= 1;
     for ($args->{lang}) {
         $_ //= $ENV{LANG} || $ENV{LANGUAGE} || "en_US";
         s/\W.*//; 
     }
 }
 
 sub _process_clause {
     use experimental 'smartmatch';
 
     my ($self, $cd, $clset_num, $clause) = @_;
 
     my $th = $cd->{th};
     my $tn = $cd->{type};
     my $clsets = $cd->{clsets};
 
     my $clset = $clsets->[$clset_num];
     local $cd->{spath}       = [@{$cd->{spath}}, $clause];
     local $cd->{clset}       = $clset;
     local $cd->{clset_num}   = $clset_num;
     local $cd->{uclset}      = $cd->{uclsets}[$clset_num];
     local $cd->{clset_dlang} = $cd->{_clset_dlangs}[$clset_num];
 
     delete $cd->{uclset}{$clause};
     delete $cd->{uclset}{"$clause.prio"};
 
     if ($clause ~~ @{ $cd->{args}{skip_clause} }) {
         delete $cd->{uclset}{$_}
             for grep /^\Q$clause\E(\.|\z)/, keys(%{$cd->{uclset}});
         return;
     }
 
     my $meth  = "clause_$clause";
     my $mmeth = "clausemeta_$clause";
     unless ($th->can($meth)) {
         for ($cd->{args}{on_unhandled_clause}) {
             next if $_ eq 'ignore';
             do { warn "Can't handle clause $clause"; next }
                 if $_ eq 'warn';
             $self->_die($cd, "Can't handle clause $clause");
         }
     }
 
 
     my $meta;
     if ($th->can($mmeth)) {
         $meta = $th->$mmeth;
     } else {
         $meta = {};
     }
     local $cd->{cl_meta} = $meta;
     $self->_die($cd, "Clause $clause doesn't allow expression")
         if $clset->{"$clause.is_expr"} && !$meta->{allow_expr};
     for my $a (keys %{ $meta->{attrs} }) {
         my $av = $meta->{attrs}{$a};
         $self->_die($cd, "Attribute $clause.$a doesn't allow ".
                         "expression")
             if $clset->{"$clause.$a.is_expr"} && !$av->{allow_expr};
     }
     local $cd->{clause} = $clause;
     my $cv = $clset->{$clause};
     my $ie = $clset->{"$clause.is_expr"};
     my $op = $clset->{"$clause.op"};
     local $cd->{cl_value}   = $cv;
     local $cd->{cl_term}    = $ie ? $self->expr($cv) : $self->literal($cv);
     local $cd->{cl_is_expr} = $ie;
     local $cd->{cl_op}      = $op;
     delete $cd->{uclset}{"$clause.is_expr"};
     delete $cd->{uclset}{"$clause.op"};
 
     if ($self->can("before_clause")) {
         $self->before_clause($cd);
     }
     if ($th->can("before_clause")) {
         $th->before_clause($cd);
     }
     my $tmpnam = "before_clause_$clause";
     if ($th->can($tmpnam)) {
         $th->$tmpnam($cd);
     }
 
     my $is_multi;
     if (defined($op) && !$ie) {
         if ($op =~ /\A(and|or|none)\z/) {
             $is_multi = 1;
         } elsif ($op eq 'not') {
             $is_multi = 0;
         } else {
             $self->_die($cd, "Invalid value for $clause.op, ".
                             "must be one of and/or/not/none");
         }
     }
     $self->_die($cd, "'$clause.op' attribute set to $op, ".
                     "but value of '$clause' clause not an array")
         if $is_multi && ref($cv) ne 'ARRAY';
     if (!$th->can($meth)) {
     } elsif ($cd->{CLAUSE_DO_MULTI} || !$is_multi) {
         local $cd->{cl_is_multi} = 1 if $is_multi;
         $th->$meth($cd);
     } else {
         my $i = 0;
         for my $cv2 (@$cv) {
             local $cd->{spath} = [@{ $cd->{spath} }, $i];
             local $cd->{cl_value} = $cv2;
             local $cd->{cl_term}  = $self->literal($cv2);
             local $cd->{_debug_ccl_note} = "" if $i;
             $i++;
             $th->$meth($cd);
         }
     }
 
     $tmpnam = "after_clause_$clause";
     if ($th->can($tmpnam)) {
         $th->$tmpnam($cd);
     }
     if ($th->can("after_clause")) {
         $th->after_clause($cd);
     }
     if ($self->can("after_clause")) {
         $self->after_clause($cd);
     }
 
     delete $cd->{uclset}{"$clause.err_msg"};
     delete $cd->{uclset}{"$clause.err_level"};
     delete $cd->{uclset}{$_} for
         grep /\A\Q$clause\E\.human(\..+)?\z/, keys(%{$cd->{uclset}});
 }
 
 sub _process_clsets {
     my ($self, $cd, $which) = @_;
 
 
     my $th = $cd->{th};
     my $tn = $cd->{type};
     my $clsets = $cd->{clsets};
 
     my $cname = $self->name;
     local $cd->{uclsets} = [];
     $cd->{_clset_dlangs} = []; 
     for my $clset (@$clsets) {
         for (keys %$clset) {
             if (!$cd->{args}{allow_expr} && /\.is_expr\z/ && $clset->{$_}) {
                 $self->_die($cd, "Expression not allowed: $_");
             }
         }
         push @{ $cd->{uclsets} }, {
             map {$_=>$clset->{$_}}
                 grep {
                     !/\A_|\._/ && (!/\Ac\./ || /\Ac\.\Q$cname\E\./)
                 } keys %$clset
         };
         my $dl = $clset->{default_lang} // $cd->{outer_cd}{clset_dlang} //
             "en_US";
         push @{ $cd->{_clset_dlangs} }, $dl;
     }
 
     my $clauses = $self->_get_clauses_from_clsets($cd, $clsets);
     $cd->{has_constraint_clause} = 0;
     for my $cl (@$clauses) {
         next if $cl->[1] =~ /\A(req|forbidden)\z/;
         next unless !$cl->[2]{tags} ||
             grep {$_ eq 'constraint'} @{ $cl->[2]{tags} };
         $cd->{has_constraint_clause} = 1;
         last;
     }
 
     if ($which) {
         if ($self->can("before_clause_sets")) {
             $self->before_clause_sets($cd);
         }
         if ($th->can("before_clause_sets")) {
             $th->before_clause_sets($cd);
         }
     } else {
         if ($self->can("before_handle_type")) {
             $self->before_handle_type($cd);
         }
 
         $th->handle_type($cd);
 
         if ($self->can("before_all_clauses")) {
             $self->before_all_clauses($cd);
         }
         if ($th->can("before_all_clauses")) {
             $th->before_all_clauses($cd);
         }
     }
 
     for my $clause0 (@$clauses) {
         my ($clset_num, $clause) = @$clause0;
         $self->_process_clause($cd, $clset_num, $clause);
     } 
 
     for my $uclset (@{ $cd->{uclsets} }) {
         if (keys %$uclset) {
             for ($cd->{args}{on_unhandled_attr}) {
                 my $msg = "Unhandled attribute(s) for type $tn: ".
                     join(", ", keys %$uclset);
                 next if $_ eq 'ignore';
                 do { warn $msg; next } if $_ eq 'warn';
                 $self->_die($cd, $msg);
             }
         }
     }
 
     if ($which) {
         if ($th->can("after_clause_sets")) {
             $th->after_clause_sets($cd);
         }
         if ($self->can("after_clause_sets")) {
             $self->after_clause_sets($cd);
         }
     } else {
         if ($th->can("after_all_clauses")) {
             $th->after_all_clauses($cd);
         }
         if ($self->can("after_all_clauses")) {
             $self->after_all_clauses($cd);
         }
     }
 }
 
 sub compile {
     my ($self, %args) = @_;
 
     $self->check_compile_args(\%args);
 
     my $main   = $self->main;
     my $cd     = $self->init_cd(%args);
 
     if ($self->can("before_compile")) {
         $self->before_compile($cd);
     }
 
     my $schema0 = $args{schema} or $self->_die($cd, "No schema");
     my $nschema;
     if ($args{schema_is_normalized}) {
         $nschema = $schema0;
     } else {
         $nschema = $main->normalize_schema($schema0);
     }
     $cd->{nschema} = $nschema;
     local $cd->{schema} = $nschema;
 
     {
         my $defs = $nschema->[2]{def};
         if ($defs) {
             for my $name (sort keys %$defs) {
                 my $def = $defs->{$name};
                 my $opt = $name =~ s/[?]\z//;
                 local $cd->{def_optional} = $opt;
                 local $cd->{def_name}     = $name;
                 $self->_die($cd, "Invalid name syntax in def: '$name'")
                     unless $name =~ $Data::Sah::type_re;
                 local $cd->{def_def}      = $def;
                 $self->def($cd);
             }
         }
     }
 
     my $res       = $self->_resolve_base_type(schema=>$nschema, cd=>$cd);
     my $tn        = $res->[0];
     my $th        = $self->get_th(name=>$tn, cd=>$cd);
     my $clsets    = $res->[1];
     $cd->{th}     = $th;
     $cd->{type}   = $tn;
     $cd->{clsets} = $clsets;
 
     $self->_process_clsets($cd);
 
     if ($self->can("after_compile")) {
         $self->after_compile($cd);
     }
 
     if ($args{log_result}) {
         require String::LineNumber;
         $log->tracef(
             "Schema compilation result:\n%s",
             !ref($cd->{result}) && ($ENV{LINENUM} // 1) ?
                 String::LineNumber::linenum($cd->{result}) :
                       $cd->{result}
                   );
     }
     return $cd;
 }
 
 sub def {
     my ($self, $cd) = @_;
     my $name = $cd->{def_name};
     my $def  = $cd->{def_def};
     my $opt  = $cd->{def_optional};
 
     my $th = $self->get_th(cd=>$cd, name=>$name, load=>0);
     if ($th) {
         if ($opt) {
             return;
         }
         $self->_die($cd, "Redefining existing type ($name) not allowed");
     }
 
     my $nschema = $self->main->normalize_schema($def);
     $cd->{th_map}{$name} = $nschema;
 }
 
 sub _ignore_clause {
     my ($self, $cd) = @_;
     my $cl = $cd->{clause};
     delete $cd->{uclset}{$cl};
 }
 
 sub _ignore_clause_and_attrs {
     my ($self, $cd) = @_;
     my $cl = $cd->{clause};
     delete $cd->{uclset}{$cl};
     delete $cd->{uclset}{$_} for grep /\A\Q$cl\E\./, keys %{$cd->{uclset}};
 }
 
 sub _die_unimplemented_clause {
     my ($self, $cd, $note) = @_;
 
     $self->_die($cd, "Clause '$cd->{clause}' for type '$cd->{type}' ".
                     ($note ? "($note) " : "") .
                         "is currently unimplemented");
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/Prog.pm ###
 package Data::Sah::Compiler::Prog;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 use Log::Any::IfLOG qw($log);
 
 use Mo qw(build default);
 extends 'Data::Sah::Compiler';
 
 
 has hc => (is => 'rw');
 
 has comment_style => (is => 'rw');
 
 has var_sigil => (is => 'rw');
 
 has concat_op => (is => 'rw');
 
 has logical_and_op => (is => 'rw', default => sub {'&&'});
 
 has logical_not_op => (is => 'rw', default => sub {'!'});
 
 
 sub init_cd {
     my ($self, %args) = @_;
 
     my $cd = $self->SUPER::init_cd(%args);
     $cd->{vars} = {};
 
     my $hc = $self->hc;
     if (!$hc) {
         $hc = $self->main->get_compiler("human");
         $self->hc($hc);
     }
 
     if (my $ocd = $cd->{outer_cd}) {
         $cd->{vars}    = $ocd->{vars};
         $cd->{modules} = $ocd->{modules};
         $cd->{_hc}     = $ocd->{_hc};
         $cd->{_hcd}    = $ocd->{_hcd};
         $cd->{_subdata_level} = $ocd->{_subdata_level};
     } else {
         $cd->{vars}    = {};
         $cd->{modules} = [];
         $cd->{_hc}     = $hc;
         $cd->{_subdata_level} = 0;
     }
 
     $cd;
 }
 
 sub check_compile_args {
     my ($self, $args) = @_;
 
     return if $args->{_args_checked_Prog}++;
 
     $self->SUPER::check_compile_args($args);
 
     my $ct = ($args->{code_type} //= 'validator');
     if ($ct ne 'validator') {
         $self->_die({}, "code_type currently can only be 'validator'");
     }
     my $rt = ($args->{return_type} //= 'bool');
     if ($rt !~ /\A(bool|str|full)\z/) {
         $self->_die({}, "Invalid value for return_type, ".
                         "use bool|str|full");
     }
     $args->{var_prefix} //= "_sahv_";
     $args->{sub_prefix} //= "_sahs_";
     $args->{data_term}  //= $self->var_sigil . $args->{data_name};
     $args->{data_term_is_lvalue} //= 1;
     $args->{tmp_data_name} //= "tmp_$args->{data_name}";
     $args->{tmp_data_term} //= $self->var_sigil . $args->{tmp_data_name};
     $args->{comment}    //= 1;
     $args->{err_term}   //= $self->var_sigil . "err_$args->{data_name}";
 }
 
 sub comment {
     my ($self, $cd, @args) = @_;
     return '' unless $cd->{args}{comment};
 
     my $content = join("", @args);
     $content =~ s/\n+/ /g;
 
     my $style = $self->comment_style;
     if ($style eq 'shell') {
         return join("", "# ", $content, "\n");
     } elsif ($style eq 'shell2') {
         return join("", "## ", $content, "\n");
     } elsif ($style eq 'cpp') {
         return join("", "// ", $content, "\n");
     } elsif ($style eq 'c') {
         return join("", "/* ", $content, '*/');
     } elsif ($style eq 'ini') {
         return join("", "; ", $content, "\n");
     } else {
         $self->_die($cd, "BUG: Unknown comment style: $style");
     }
 }
 
 sub enclose_paren {
     my ($self, $expr, $force) = @_;
     if ($expr =~ /\A(\s*)(\(.+\)\s*)\z/os) {
         return $expr if !$force;
         return "$1($2)";
     } else {
         $expr =~ /\A(\s*)(.*)/os;
         return "$1($2)";
     }
 }
 
 sub add_module {
     use experimental 'smartmatch';
 
     my ($self, $cd, $name) = @_;
 
     return 0 if $name ~~ @{ $cd->{modules} };
     push @{ $cd->{modules} }, $name;
     1;
 }
 
 sub add_var {
     my ($self, $cd, $name, $value) = @_;
 
     return if exists $cd->{vars}{$name};
     $cd->{vars}{$name} = $value;
 }
 
 
 sub expr_assign {
     my ($self, $v, $t) = @_;
     "$v = $t";
 }
 
 sub _xlt {
     my ($self, $cd, $text) = @_;
 
     my $hc  = $cd->{_hc};
     my $hcd = $cd->{_hcd};
     $hc->_xlt($hcd, $text);
 }
 
 sub expr_concat {
     my ($self, @t) = @_;
     join(" " . $self->concat_op . " ", @t);
 }
 
 sub expr_var {
     my ($self, $v) = @_;
     $self->var_sigil. $v;
 }
 
 sub expr_preinc {
     my ($self, $t) = @_;
     "++$t";
 }
 
 sub expr_preinc_var {
     my ($self, $v) = @_;
     "++" . $self->var_sigil. $v;
 }
 
 
 sub expr_validator_sub {
     my ($self, %args) = @_;
 
     my $log_result = delete $args{log_result};
     my $dt         = $args{data_term};
     my $vt         = delete($args{var_term}) // $dt;
     my $do_log     = $args{debug_log} // $args{debug};
     my $rt         = $args{return_type} // 'bool';
 
     $args{indent_level} = 1;
 
     my $cd = $self->compile(%args);
     my $et = $cd->{args}{err_term};
 
     if ($rt ne 'bool') {
         my ($ev) = $et =~ /(\w+)/; 
         $self->add_var($cd, $ev, $rt eq 'str' ? undef : {});
     }
     my $resv = '_sahv_res';
     my $rest = $self->var_sigil . $resv;
 
     my $needs_expr_block = @{ $cd->{modules} } || $do_log;
 
     my $code = join(
         "",
         ($self->stmt_require_log_module."\n") x !!$do_log,
         (map { $self->stmt_require_module($_, $cd)."\n" } @{ $cd->{modules} }),
         $self->expr_anon_sub(
             [$vt],
             join(
                 "",
                 (map {$self->stmt_declare_local_var(
                     $_, $self->literal($cd->{vars}{$_}))."\n"}
                      sort keys %{ $cd->{vars} }),
                 $self->stmt_declare_local_var($resv, "\n\n" . $cd->{result})."\n\n",
 
                 ($self->stmt_return($rest)."\n")
                     x !!($rt eq 'bool'),
 
                 ($self->expr_set_err_str($et, $self->literal('')).";",
                  "\n\n".$self->stmt_return($et)."\n")
                     x !!($rt eq 'str'),
 
                 ($self->stmt_return($et)."\n")
                     x !!($rt eq 'full'),
             )
         ),
     );
 
     if ($needs_expr_block) {
         $code = $self->expr_block($code);
     }
 
     if ($log_result && $log->is_trace) {
         require String::LineNumber;
         $log->tracef("validator code:\n%s",
                      ($ENV{LINENUM} // 1) ?
                          String::LineNumber::linenum($code) :
                                $code);
     }
 
     $code;
 }
 
 sub add_ccl {
     my ($self, $cd, $ccl, $opts) = @_;
     $opts //= {};
     my $clause = $cd->{clause} // "";
     my $op     = $cd->{cl_op} // "";
 
     my $use_dpath = $cd->{args}{return_type} ne 'bool';
 
     my $el = $opts->{err_level} // $cd->{clset}{"$clause.err_level"} // "error";
     my $err_expr = $opts->{err_expr};
     my $err_msg  = $opts->{err_msg};
 
     if (defined $err_expr) {
         $self->add_var($cd, '_sahv_dpath', []) if $use_dpath;
         $err_expr = $self->expr_prefix_dpath($err_expr) if $use_dpath;
     } else {
         unless (defined $err_msg) { $err_msg = $cd->{clset}{"$clause.err_msg"} }
         unless (defined $err_msg) {
 
             my @msgpath = @{$cd->{spath}};
             my $msgpath;
             my $hc  = $cd->{_hc};
             my $hcd = $cd->{_hcd};
             while (1) {
                 last unless @msgpath;
                 $msgpath = join("/", @msgpath);
                 my $ccls = $hcd->{result}{$msgpath};
                 pop @msgpath;
                 if ($ccls) {
                     local $hcd->{args}{format} = 'inline_err_text';
                     $err_msg = $hc->format_ccls($hcd, $ccls);
                     $err_msg = "(msgpath=$msgpath) $err_msg"
                         if $cd->{args}{debug};
                     last;
                 }
             }
             if (!$err_msg) {
                 $err_msg = "ERR (clause=".($cd->{clause} // "").")";
             } else {
                 $err_msg = ucfirst($err_msg);
             }
         }
         if ($err_msg) {
             $self->add_var($cd, '_sahv_dpath', []) if $use_dpath;
             $err_expr = $self->literal($err_msg);
             $err_expr = $self->expr_prefix_dpath($err_expr) if $use_dpath;
         }
     }
 
     my $rt = $cd->{args}{return_type};
     my $et = $cd->{args}{err_term};
     my $err_code;
     if ($rt eq 'full') {
         $self->add_var($cd, '_sahv_dpath', []) if $use_dpath;
         my $k = $el eq 'warn' ? 'warnings' : 'errors';
         $err_code = $self->expr_set_err_full($et, $k, $err_expr) if $err_expr;
     } elsif ($rt eq 'str') {
         if ($el ne 'warn') {
             $err_code = $self->expr_set_err_str($et, $err_expr) if $err_expr;
         }
     }
 
     my $res = {
         ccl             => $ccl,
         err_level       => $el,
         err_code        => $err_code,
         (_debug_ccl_note => $cd->{_debug_ccl_note}) x !!$cd->{_debug_ccl_note},
         subdata         => $opts->{subdata},
     };
     push @{ $cd->{ccls} }, $res;
     delete $cd->{uclset}{"$clause.err_level"};
     delete $cd->{uclset}{"$clause.err_msg"};
 }
 
 sub join_ccls {
     my ($self, $cd, $ccls, $opts) = @_;
     $opts //= {};
     my $op = $opts->{op} // "and";
 
     my ($min_ok, $max_ok, $min_nok, $max_nok);
     if ($op eq 'and') {
         $max_nok = 0;
     } elsif ($op eq 'or') {
         $min_ok = 1;
     } elsif ($op eq 'none') {
         $max_ok = 0;
     } elsif ($op eq 'not') {
 
     }
     my $dmin_ok  = defined($min_ok);
     my $dmax_ok  = defined($max_ok);
     my $dmin_nok = defined($min_nok);
     my $dmax_nok = defined($max_nok);
 
     return "" unless @$ccls;
 
     my $rt      = $cd->{args}{return_type};
     my $vp      = $cd->{args}{var_prefix};
 
     my $aop = $self->logical_and_op;
     my $nop = $self->logical_not_op;
 
     my $true = $self->true;
 
     my $_ice = sub {
         my ($ccl, $which) = @_;
 
         return $self->enclose_paren($ccl->{ccl}) if $ccl->{assert};
 
         my $res = "";
 
         if ($ccl->{_debug_ccl_note}) {
             if ($cd->{args}{debug_log} // $cd->{args}{debug}) {
                 $res .= $self->expr_log(
                     $cd, $self->literal($ccl->{_debug_ccl_note})) . " $aop\n";
             } else {
                 $res .= $self->comment($cd, $ccl->{_debug_ccl_note});
             }
         }
 
         $which //= 0;
         my $cc = ($which == 1 ? $nop:"") . $self->enclose_paren($ccl->{ccl});
         my ($ec, $oec);
         my ($ret, $oret);
         if ($which >= 2) {
             my @chk;
             if ($ccl->{err_level} eq 'warn') {
                 $oret = 1;
                 $ret  = 1;
             } elsif ($ccl->{err_level} eq 'fatal') {
                 $oret = 1;
                 $ret  = 0;
             } else {
                 $oret = $self->expr_preinc_var("${vp}ok");
                 $ret  = $self->expr_preinc_var("${vp}nok");
                 push @chk, $self->expr_var("${vp}ok"). " <= $max_ok"
                     if $dmax_ok;
                 push @chk, $self->expr_var("${vp}nok")." <= $max_nok"
                     if $dmax_nok;
                 if ($which == 3) {
                     push @chk, $self->expr_var("${vp}ok"). " >= $min_ok"
                         if $dmin_ok;
                     push @chk, $self->expr_var("${vp}nok")." >= $min_nok"
                         if $dmin_nok;
 
                     if ($rt ne 'bool') {
                         my $et = $cd->{args}{err_term};
                         my $clerrc;
                         if ($rt eq 'full') {
                             $clerrc = $self->expr_reset_err_full($et);
                         } else {
                             $clerrc = $self->expr_reset_err_str($et);
                         }
                         push @chk, $clerrc;
                     }
                 }
             }
             $res .= "($cc ? $oret : $ret)";
             $res .= " $aop " . join(" $aop ", @chk) if @chk;
         } else {
             $ec = $ccl->{err_code};
             $ret =
                 $ccl->{err_level} eq 'fatal' ? 0 :
                         $ccl->{err_level} eq 'warn' ? 1 : 0;
             if ($rt eq 'bool' && $ret) {
                 $res .= $true;
             } elsif ($rt eq 'bool' || !$ec) {
                 $res .= $self->enclose_paren($cc);
             } else {
                 $res .= $self->enclose_paren(
                     $self->enclose_paren($cc). " ? $true : ($ec,$ret)",
                     "force");
             }
         }
 
         my $use_dpath = $rt ne 'bool' && $ccl->{subdata};
         $res = $self->expr_push_and_pop_dpath_between_expr($res) if $use_dpath;
         $res;
 
     };
 
     my $j = "\n\n$aop\n\n";
     if ($op eq 'not') {
         return $_ice->($ccls->[0], 1);
     } elsif ($op eq 'and') {
         return join $j, map { $_ice->($_) } @$ccls;
     } elsif ($op eq 'none') {
         return join $j, map { $_ice->($_, 1) } @$ccls;
     } else {
         my $jccl = join $j, map {$_ice->($ccls->[$_], $_ == @$ccls-1 ? 3:2)}
             0..@$ccls-1;
         {
             local $cd->{ccls} = [];
             local $cd->{_debug_ccl_note} = "op=$op";
             $self->add_ccl(
                 $cd,
                 $self->expr_block(
                     join(
                         "",
                         $self->stmt_declare_local_var("${vp}ok" , "0"), "\n",
                         $self->stmt_declare_local_var("${vp}nok", "0"), "\n",
                         "\n",
                         $self->block_uses_sub ?
                             $self->stmt_return($jccl) : $jccl,
                     )
                 ),
             );
             $_ice->($cd->{ccls}[0]);
         }
     }
 }
 
 sub before_compile {
     my ($self, $cd) = @_;
 
     if ($cd->{args}{data_term_is_lvalue}) {
         $cd->{data_term} = $cd->{args}{data_term};
     } else {
         my $v = $cd->{args}{var_prefix} . $cd->{args}{data_name};
         push @{ $cd->{vars} }, $v; 
         $cd->{data_term} = $self->var_sigil . $v;
         push @{ $cd->{ccls} }, ["(local($cd->{data_term} = $cd->{args}{data_term}), 1)"];
     }
 }
 
 sub before_handle_type {
     my ($self, $cd) = @_;
 
 
     unless ($cd->{_inner}) {
         my $hc = $cd->{_hc};
         my %hargs = %{$cd->{args}};
         $hargs{format}               = 'msg_catalog';
         $hargs{schema_is_normalized} = 1;
         $hargs{schema}               = $cd->{nschema};
         $hargs{on_unhandled_clause}  = 'ignore';
         $hargs{on_unhandled_attr}    = 'ignore';
         $hargs{hash_values}          = $cd->{args}{human_hash_values};
         $cd->{_hcd} = $hc->compile(%hargs);
     }
 }
 
 sub before_all_clauses {
     my ($self, $cd) = @_;
 
 
     my $dt     = $cd->{data_term};
     my $clsets = $cd->{clsets};
 
     for my $i (0..@$clsets-1) {
         my $clset  = $clsets->[$i];
         next unless exists $clset->{ok};
         my $op = $clset->{"ok.op"} // "";
         if ($op && $op ne 'not') {
             $self->_die($cd, "ok can only be combined with .op=not");
         }
         if ($op eq 'not') {
             local $cd->{_debug_ccl_note} = "!ok #$i";
             $self->add_ccl($cd, $self->false);
         } else {
             local $cd->{_debug_ccl_note} = "ok #$i";
             $self->add_ccl($cd, $self->true);
         }
         delete $cd->{uclsets}[$i]{"ok"};
         delete $cd->{uclsets}[$i]{"ok.is_expr"};
     }
 
     for my $i (0..@$clsets-1) {
         my $clset  = $clsets->[$i];
         my $def    = $clset->{default};
         my $defie  = $clset->{"default.is_expr"};
         if (defined $def) {
             local $cd->{_debug_ccl_note} = "default #$i";
             my $ct = $defie ?
                 $self->expr($def) : $self->literal($def);
             $self->add_ccl(
                 $cd,
                 "(".$self->expr_setif($dt, $ct).", ".$self->true.")",
                 {err_msg => ""},
             );
         }
         delete $cd->{uclsets}[$i]{"default"};
         delete $cd->{uclsets}[$i]{"default.is_expr"};
     }
 
 
     my $has_req;
     for my $i (0..@$clsets-1) {
         my $clset  = $clsets->[$i];
         my $req    = $clset->{req};
         my $reqie  = $clset->{"req.is_expr"};
         my $req_err_msg = $self->_xlt($cd, "Required but not specified");
         local $cd->{_debug_ccl_note} = "req #$i";
         if ($req && !$reqie) {
             $has_req++;
             $self->add_ccl(
                 $cd, $self->expr_defined($dt),
                 {
                     err_msg   => $req_err_msg,
                     err_level => 'fatal',
                 },
             );
         } elsif ($reqie) {
             $has_req++;
             my $ct = $self->expr($req);
             $self->add_ccl(
                 $cd, "!($ct) || ".$self->expr_defined($dt),
                 {
                     err_msg   => $req_err_msg,
                     err_level => 'fatal',
                 },
             );
         }
         delete $cd->{uclsets}[$i]{"req"};
         delete $cd->{uclsets}[$i]{"req.is_expr"};
     }
 
     my $has_fbd;
     for my $i (0..@$clsets-1) {
         my $clset  = $clsets->[$i];
         my $fbd    = $clset->{forbidden};
         my $fbdie  = $clset->{"forbidden.is_expr"};
         my $fbd_err_msg = $self->_xlt($cd, "Forbidden but specified");
         local $cd->{_debug_ccl_note} = "forbidden #$i";
         if ($fbd && !$fbdie) {
             $has_fbd++;
             $self->add_ccl(
                 $cd, "!".$self->expr_defined($dt),
                 {
                     err_msg   => $fbd_err_msg,
                     err_level => 'fatal',
                 },
             );
         } elsif ($fbdie) {
             $has_fbd++;
             my $ct = $self->expr($fbd);
             $self->add_ccl(
                 $cd, "!($ct) || !".$self->expr_defined($dt),
                 {
                     err_msg   => $fbd_err_msg,
                     err_level => 'fatal',
                 },
             );
         }
         delete $cd->{uclsets}[$i]{"forbidden"};
         delete $cd->{uclsets}[$i]{"forbidden.is_expr"};
     }
 
     if (!$has_req && !$has_fbd) {
         $cd->{_skip_undef} = 1;
         $cd->{_ccls_idx1} = @{$cd->{ccls}};
     }
 
 
     $self->_die($cd, "BUG: type handler did not produce _ccl_check_type")
         unless defined($cd->{_ccl_check_type});
     local $cd->{_debug_ccl_note} = "check type '$cd->{type}'";
     $self->add_ccl(
         $cd, $cd->{_ccl_check_type},
         {
             err_msg   => sprintf(
                 $self->_xlt($cd, "Not of type %s"),
                 $self->_xlt(
                     $cd,
                     $cd->{_hc}->get_th(name=>$cd->{type})->name //
                         $cd->{type}
                     ),
             ),
             err_level => 'fatal',
         },
     );
 }
 
 sub before_clause {
     my ($self, $cd) = @_;
 
     $self->_die($cd, "Sorry, .op + .is_expr not yet supported ".
                     "(found in clause $cd->{clause})")
         if $cd->{cl_is_expr} && $cd->{cl_op};
 
     if ($cd->{args}{debug}) {
         state $json = do {
             require JSON;
             JSON->new->allow_nonref;
         };
         my $clset = $cd->{clset};
         my $cl    = $cd->{clause};
         my $res   = $json->encode({
             map { $_ => $clset->{$_}}
                 grep {/\A\Q$cl\E(?:\.|\z)/}
                     keys %$clset });
         $res =~ s/\n+/ /g;
         $cd->{_debug_ccl_note} = "clause: $res";
     } else {
         $cd->{_debug_ccl_note} = "clause: $cd->{clause}";
     }
 
 
     push @{ $cd->{_save_ccls} }, $cd->{ccls};
     $cd->{ccls} = [];
 }
 
 sub after_clause {
     my ($self, $cd) = @_;
 
     if ($cd->{args}{debug}) {
         delete $cd->{_debug_ccl_note};
     }
 
     my $save = pop @{ $cd->{_save_ccls} };
     if (@{ $cd->{ccls} }) {
         push @$save, {
             ccl       => $self->join_ccls($cd, $cd->{ccls}, {op=>$cd->{cl_op}}),
             err_level => $cd->{clset}{"$cd->{clause}.err_level"} // "error",
         }
     }
     $cd->{ccls} = $save;
 }
 
 sub after_clause_sets {
     my ($self, $cd) = @_;
 
     $cd->{result} = $self->indent(
         $cd,
         $self->join_ccls($cd, $cd->{ccls}, {err_msg => ''}),
     );
 }
 
 sub after_all_clauses {
     my ($self, $cd) = @_;
 
     if (delete $cd->{_skip_undef}) {
         my $jccl = $self->join_ccls(
             $cd,
             [splice(@{ $cd->{ccls} }, $cd->{_ccls_idx1})],
         );
         local $cd->{_debug_ccl_note} = "skip if undef";
         $self->add_ccl(
             $cd,
             "!".$self->expr_defined($cd->{data_term})." ? ".$self->true." : \n\n".
                 $self->enclose_paren($jccl),
             {err_msg => ''},
         );
     }
 
     $cd->{result} = $self->indent(
         $cd,
         $self->join_ccls($cd, $cd->{ccls}, {err_msg => ''}),
     );
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/Prog/TH.pm ###
 package Data::Sah::Compiler::Prog::TH;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 
 extends 'Data::Sah::Compiler::TH';
 
 
 sub clause_default {}
 sub clause_ok {}
 sub clause_req {}
 sub clause_forbidden {}
 sub clause_prefilters {}
 
 
 
 sub clause_name {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause_and_attrs($cd);
 }
 
 sub clause_summary {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause_and_attrs($cd);
 }
 
 sub clause_description {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause_and_attrs($cd);
 }
 
 sub clause_comment {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause($cd);
 }
 
 sub clause_tags {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause($cd);
 }
 
 sub clause_defhash_v {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause($cd);
 }
 
 sub clause_v {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause($cd);
 }
 
 sub set_tmp_data_term {
     my ($self, $cd, $expr) = @_;
     my $c = $self->compiler;
 
     my $tdn = $cd->{args}{tmp_data_name};
     my $tdt = $cd->{args}{tmp_data_term};
     my $t = $c->expr_array_subscript($tdt, $cd->{_subdata_level});
     unless ($cd->{_save_data_term}) {
         $c->add_var($cd, $tdn, []);
         $cd->{_save_data_term} = $cd->{data_term};
         $cd->{data_term} = $t;
     }
     local $cd->{_debug_ccl_note} = 'set temporary data term';
     $c->add_ccl($cd, "(".$c->expr_assign($t, $expr). ", ".$c->true.")");
 }
 
 sub restore_data_term {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $tdt = $cd->{args}{tmp_data_term};
     if ($cd->{_save_data_term}) {
         $cd->{data_term} = delete($cd->{_save_data_term});
         local $cd->{_debug_ccl_note} = 'restore original data term';
         $c->add_ccl($cd, "(".$c->expr_pop($tdt). ", ".$c->true.")");
     }
 }
 
 sub gen_any_or_all_of {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $dt = $cd->{data_term};
 
     my $jccl;
     {
         local $cd->{ccls} = [];
         for my $i (0..@$cv-1) {
             local $cd->{spath} = [@{ $cd->{spath} }, $i];
             my $sch  = $cv->[$i];
             my %iargs = %{$cd->{args}};
             $iargs{outer_cd}             = $cd;
             $iargs{schema}               = $sch;
             $iargs{schema_is_normalized} = 0;
             $iargs{indent_level}++;
             my $icd  = $c->compile(%iargs);
             my @code = (
                 $icd->{result},
             );
             $c->add_ccl($cd, join("", @code));
         }
         if ($which eq 'all') {
             $jccl = $c->join_ccls(
                 $cd, $cd->{ccls}, {err_msg=>''});
         } else {
             $jccl = $c->join_ccls(
                 $cd, $cd->{ccls}, {err_msg=>'', op=>'or'});
         }
     }
     $c->add_ccl($cd, $jccl);
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/Prog/TH/all.pm ###
 package Data::Sah::Compiler::Prog::TH::all;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::Prog::TH';
 with 'Data::Sah::Type::all';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = $c->true;
 }
 
 sub clause_of {
     my ($self, $cd) = @_;
     $self->gen_any_or_all_of("all", $cd);
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/Prog/TH/any.pm ###
 package Data::Sah::Compiler::Prog::TH::any;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH';
 with 'Data::Sah::Type::any';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = $c->true;
 }
 
 sub clause_of {
     my ($self, $cd) = @_;
     $self->gen_any_or_all_of("any", $cd);
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/TH.pm ###
 package Data::Sah::Compiler::TH;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 use Mo qw(build default);
 
 has compiler => (is => 'rw');
 
 sub clause_v {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause($cd);
 }
 
 sub clause_defhash_v {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause($cd);
 }
 
 sub clause_schema_v {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause($cd);
 }
 
 sub clause_base_v {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause($cd);
 }
 
 sub clause_default_lang {
     my ($self, $cd) = @_;
     $self->compiler->_ignore_clause($cd);
 }
 
 sub clause_clause {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     my ($clause, $clv) = @$cv;
     my $meth   = "clause_$clause";
     my $mmeth  = "clausemeta_$clause";
 
     my $clsets = [{$clause => $clv}];
     local $cd->{clsets} = $clsets;
 
     $c->_process_clause($cd, 0, $clause);
 }
 
 
 sub clause_clset {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     local $cd->{clsets} = [$cv];
     $c->_process_clsets($cd, 'from clause_clset');
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/TextResultRole.pm ###
 package Data::Sah::Compiler::TextResultRole;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(default);
 use Role::Tiny;
 
 use String::Indent ();
 
 has indent_character => (is => 'rw', default => sub {''});
 
 sub add_result {
     my ($self, $cd, @args) = @_;
 
     $cd->{result} //= [];
     push @{ $cd->{result} }, $self->indent($cd, join("", @args));
     $self;
 }
 
 sub indent {
     my ($self, $cd, $str) = @_;
     String::Indent::indent(
         $self->indent_character x $cd->{indent_level},
         $str,
     );
 }
 
 sub inc_indent {
     my ($self, $cd) = @_;
     $cd->{indent_level}++;
 }
 
 sub dec_indent {
     my ($self, $cd) = @_;
     $cd->{indent_level}--;
 }
 
 sub indent_str {
     my ($self, $cd) = @_;
     $self->indent_character x $cd->{indent_level};
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human.pm ###
 package Data::Sah::Compiler::human;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Data::Dmp qw(dmp);
 use Mo qw(build default);
 use POSIX qw(locale_h);
 use Text::sprintfn;
 
 extends 'Data::Sah::Compiler';
 
 our %typex; 
 
 sub name { "human" }
 
 sub _add_msg_catalog {
     my ($self, $cd, $msg) = @_;
     return unless $cd->{args}{format} eq 'msg_catalog';
 
     my $spath = join("/", @{ $cd->{spath} });
     $cd->{_msg_catalog}{$spath} = $msg;
 }
 
 sub check_compile_args {
     use experimental 'smartmatch';
 
     my ($self, $args) = @_;
 
     $self->SUPER::check_compile_args($args);
 
     my @fmts = ('inline_text', 'inline_err_text', 'markdown', 'msg_catalog');
     $args->{format} //= $fmts[0];
     unless ($args->{format} ~~ @fmts) {
         $self->_die({}, "Unsupported format, use one of: ".join(", ", @fmts));
     }
 }
 
 sub init_cd {
     my ($self, %args) = @_;
 
     my $cd = $self->SUPER::init_cd(%args);
     if (($cd->{args}{format} // '') eq 'msg_catalog') {
         $cd->{_msg_catalog} //= $cd->{outer_cd}{_msg_catalog};
         $cd->{_msg_catalog} //= {};
     }
     $cd;
 }
 
 sub expr {
     my ($self, $cd, $expr) = @_;
 
 
     $expr;
 }
 
 sub literal {
     my ($self, $val) = @_;
 
     return $val unless ref($val);
     dmp($val);
 }
 
 sub _xlt {
     my ($self, $cd, $text) = @_;
 
     my $lang = $cd->{args}{lang};
 
 
     return $text if $lang eq 'en_US';
     my $translations;
     {
         no strict 'refs';
         $translations = \%{"Data::Sah::Lang::$lang\::translations"};
     }
     return $translations->{$text} if defined($translations->{$text});
     if ($cd->{args}{mark_missing_translation}) {
         return "(no $lang text:$text)";
     } else {
         return $text;
     }
 }
 
 sub _ordinate {
     my ($self, $cd, $n, $noun) = @_;
 
     my $lang = $cd->{args}{lang};
 
 
     if ($lang eq 'en_US') {
         require Lingua::EN::Numbers::Ordinate;
         return Lingua::EN::Numbers::Ordinate::ordinate($n) . " $noun";
     } else {
         no strict 'refs';
         return "Data::Sah::Lang::$lang\::ordinate"->($n, $noun);
     }
 }
 
 sub _add_ccl {
     use experimental 'smartmatch';
 
     my ($self, $cd, $ccl) = @_;
 
     $ccl->{xlt} //= 1;
 
     my $clause = $cd->{clause} // "";
     $ccl->{type} //= "clause";
 
     my $do_xlt = 1;
 
     my $hvals = {
         modal_verb     => $self->_xlt($cd, "must"),
         modal_verb_neg => $self->_xlt($cd, "must not"),
 
         field          => $self->_xlt($cd, "field"),
         fields         => $self->_xlt($cd, "fields"),
 
         %{ $cd->{args}{hash_values} // {} },
     };
     my $mod="";
 
 
     {
         my $lang   = $cd->{args}{lang};
         my $dlang  = $cd->{clset_dlang} // "en_US"; 
         my $suffix = $lang eq $dlang ? "" : ".alt.lang.$lang";
         if ($clause) {
             delete $cd->{uclset}{$_} for
                 grep /\A\Q$clause.human\E(\.|\z)/, keys %{$cd->{uclset}};
             if (defined $cd->{clset}{"$clause.human$suffix"}) {
                 $ccl->{type} = 'clause';
                 $ccl->{fmt}  = $cd->{clset}{"$clause.human$suffix"};
                 goto FILL_FORMAT;
             }
         } else {
             delete $cd->{uclset}{$_} for
                 grep /\A\.name(\.|\z)/, keys %{$cd->{uclset}};
             if (defined $cd->{clset}{".name$suffix"}) {
                 $ccl->{type} = 'noun';
                 $ccl->{fmt}  = $cd->{clset}{".name$suffix"};
                 $ccl->{vals} = undef;
                 goto FILL_FORMAT;
             }
         }
     }
 
     goto TRANSLATE unless $clause;
 
     my $ie    = $cd->{cl_is_expr};
     my $im    = $cd->{cl_is_multi};
     my $op    = $cd->{cl_op} // "";
     my $cv    = $cd->{clset}{$clause};
     my $vals  = $ccl->{vals} // [$cv];
 
 
     if ($ie) {
         if (!$ccl->{expr}) {
             $ccl->{fmt} = "($clause -> %s" . ($op ? " op=$op" : "") . ")";
             $do_xlt = 0;
             $vals = [$self->expr($cd, $vals)];
         }
         goto ERR_LEVEL;
     }
 
 
     if ($op eq 'not') {
         ($hvals->{modal_verb}, $hvals->{modal_verb_neg}) =
             ($hvals->{modal_verb_neg}, $hvals->{modal_verb});
         $vals = [map {$self->literal($_)} @$vals];
     } elsif ($im && $op eq 'and') {
         if (@$cv == 2) {
             $vals = [sprintf($self->_xlt($cd, "%s and %s"),
                              $self->literal($cv->[0]),
                              $self->literal($cv->[1]))];
         } else {
             $vals = [sprintf($self->_xlt($cd, "all of %s"),
                              $self->literal($cv))];
         }
     } elsif ($im && $op eq 'or') {
         if (@$cv == 2) {
             $vals = [sprintf($self->_xlt($cd, "%s or %s"),
                              $self->literal($cv->[0]),
                              $self->literal($cv->[1]))];
         } else {
             $vals = [sprintf($self->_xlt($cd, "one of %s"),
                              $self->literal($cv))];
         }
     } elsif ($im && $op eq 'none') {
         ($hvals->{modal_verb}, $hvals->{modal_verbneg}) =
             ($hvals->{modal_verb_neg}, $hvals->{modal_verb});
         if (@$cv == 2) {
             $vals = [sprintf($self->_xlt($cd, "%s nor %s"),
                              $self->literal($cv->[0]),
                              $self->literal($cv->[1]))];
         } else {
             $vals = [sprintf($self->_xlt($cd, "any of %s"),
                              $self->literal($cv))];
         }
     } else {
         $vals = [map {$self->literal($_)} @$vals];
     }
 
   ERR_LEVEL:
 
     if ($ccl->{type} eq 'clause' && 'constraint' ~~ $cd->{cl_meta}{tags}) {
         if (($cd->{clset}{"$clause.err_level"}//'error') eq 'warn') {
             if ($op eq 'not') {
                 $hvals->{modal_verb}     = $self->_xlt($cd, "should not");
                 $hvals->{modal_verb_neg} = $self->_xlt($cd, "should");
             } else {
                 $hvals->{modal_verb}     = $self->_xlt($cd, "should");
                 $hvals->{modal_verb_neg} = $self->_xlt($cd, "should not");
             }
         }
     }
     delete $cd->{uclset}{"$clause.err_level"};
 
   TRANSLATE:
 
     if ($ccl->{xlt}) {
         if (ref($ccl->{fmt}) eq 'ARRAY') {
             $ccl->{fmt}  = [map {$self->_xlt($cd, $_)} @{$ccl->{fmt}}];
         } elsif (!ref($ccl->{fmt})) {
             $ccl->{fmt}  = $self->_xlt($cd, $ccl->{fmt});
         }
     }
 
   FILL_FORMAT:
 
     if (ref($ccl->{fmt}) eq 'ARRAY') {
         $ccl->{text} = [map {sprintfn($_, (map {$_//""} ($hvals, @$vals)))}
                             @{$ccl->{fmt}}];
     } elsif (!ref($ccl->{fmt})) {
         $ccl->{text} = sprintfn($ccl->{fmt}, (map {$_//""} ($hvals, @$vals)));
     }
     delete $ccl->{fmt} unless $cd->{args}{debug};
 
   PUSH:
     push @{$cd->{ccls}}, $ccl;
 
     $self->_add_msg_catalog($cd, $ccl);
 }
 
 sub add_ccl {
     my ($self, $cd, @ccls) = @_;
 
     my $op     = $cd->{cl_op} // '';
 
     my $ccl;
     if (@ccls == 1) {
         $self->_add_ccl($cd, $ccls[0]);
     } else {
         my $inner_cd = $self->init_cd(outer_cd => $cd);
         $inner_cd->{args} = $cd->{args};
         $inner_cd->{clause} = $cd->{clause};
         for (@ccls) {
             $self->_add_ccl($inner_cd, $_);
         }
 
         $ccl = {
             type  => 'list',
             vals  => [],
             items => $inner_cd->{ccls},
             multi => 0,
         };
         if ($op eq 'or') {
             $ccl->{fmt} = 'any of the following %(modal_verb)s be true';
         } elsif ($op eq 'and') {
             $ccl->{fmt} = 'all of the following %(modal_verb)s be true';
         } elsif ($op eq 'none') {
             $ccl->{fmt} = 'none of the following %(modal_verb)s be true';
         }
         $self->_add_ccl($cd, $ccl);
     }
 }
 
 sub format_ccls {
     my ($self, $cd, $ccls) = @_;
 
     local $cd->{_fmt_noun_count} = 0;
     local $cd->{_fmt_etc_count} = 0;
 
     my $f = $cd->{args}{format};
     my $res;
     if ($f eq 'inline_text' || $f eq 'inline_err_text' || $f eq 'msg_catalog') {
         $res = $self->_format_ccls_itext($cd, $ccls);
         if ($f eq 'inline_err_text') {
             if ($cd->{_fmt_noun_count} == 1 && $cd->{_fmt_etc_count} == 0) {
                 $res = sprintf(
                     $self->_xlt($cd, "Not of type %s"),
                     $res
                 );
             } elsif (!$cd->{_fmt_noun_count}) {
             } else {
                 $res = sprintf(
                     $self->_xlt(
                         $cd, "Does not satisfy the following schema: %s"),
                     $res
                 );
             }
         }
     } else {
         $res = $self->_format_ccls_markdown($cd, $ccls);
     }
     $res;
 }
 
 sub _format_ccls_itext {
     my ($self, $cd, $ccls) = @_;
 
     local $cd->{args}{mark_missing_translation} = 0;
     my $c_comma = $self->_xlt($cd, ", ");
 
     if (ref($ccls) eq 'HASH' && $ccls->{type} =~ /^(noun|clause)$/) {
         if ($ccls->{type} eq 'noun') {
             $cd->{_fmt_noun_count}++;
         } else {
             $cd->{_fmt_etc_count}++;
         }
         my $ccl = $ccls;
         return ref($ccl->{text}) eq 'ARRAY' ? $ccl->{text}[0] : $ccl->{text};
     } elsif (ref($ccls) eq 'HASH' && $ccls->{type} eq 'list') {
         my $c_openpar  = $self->_xlt($cd, "(");
         my $c_closepar = $self->_xlt($cd, ")");
         my $c_colon    = $self->_xlt($cd, ": ");
         my $ccl = $ccls;
 
         my $txt = $ccl->{text}; $txt =~ s/\s+$//;
         my @t = ($txt, $c_colon);
         my $i = 0;
         for (@{ $ccl->{items} }) {
             push @t, $c_comma if $i;
             my $it = $self->_format_ccls_itext($cd, $_);
             if ($it =~ /\Q$c_comma/) {
                 push @t, $c_openpar, $it, $c_closepar;
             } else {
                 push @t, $it;
             }
             $i++;
         }
         return join("", @t);
     } elsif (ref($ccls) eq 'ARRAY') {
         return join($c_comma, map {$self->_format_ccls_itext($cd, $_)} @$ccls);
     } else {
         $self->_die($cd, "Can't format $ccls");
     }
 }
 
 sub _format_ccls_markdown {
     my ($self, $cd, $ccls) = @_;
 
     $self->_die($cd, "Sorry, markdown not yet implemented");
 }
 
 sub _load_lang_modules {
     my ($self, $cd) = @_;
 
     my $lang = $cd->{args}{lang};
     die "Invalid language '$lang', please use letters only"
         unless $lang =~ /\A\w+\z/;
 
     my @modp;
     unless ($lang eq 'en_US') {
         push @modp, "Data/Sah/Lang/$lang.pm";
         for my $cl (@{ $typex{$cd->{type}} // []}) {
             my $modp = "Data/Sah/Lang/$lang/TypeX/$cd->{type}/$cl.pm";
             $modp =~ s!::!/!g; 
             push @modp, $modp;
         }
     }
     my $i;
     for my $modp (@modp) {
         $i++;
         unless (exists $INC{$modp}) {
             if ($i == 1) {
                 require Module::Path::More;
                 my $mod = $modp; $mod =~ s/\.pm$//;
                 if (!Module::Path::More::module_path(module=>$modp)) {
                     $cd->{args}{lang} = 'en_US';
                     last;
                 }
             }
             require $modp;
 
             $INC{$modp} = undef;
         }
     }
 }
 
 sub before_compile {
     my ($self, $cd) = @_;
 
     $cd->{_orig_locale} = setlocale(LC_ALL);
 
     my $res = setlocale(LC_ALL, $cd->{args}{locale} // $cd->{args}{lang});
     warn "Unsupported locale $cd->{args}{lang}"
         if $cd->{args}{debug} && !defined($res);
 }
 
 sub before_handle_type {
     my ($self, $cd) = @_;
 
     $self->_load_lang_modules($cd);
 }
 
 sub before_clause {
     my ($self, $cd) = @_;
 
     $cd->{CLAUSE_DO_MULTI} = 1;
 }
 
 sub after_clause {
     my ($self, $cd) = @_;
 
     delete $cd->{CLAUSE_DO_MULTI};
 }
 
 sub after_all_clauses {
     use experimental 'smartmatch';
 
     my ($self, $cd) = @_;
 
 
 
     $cd->{result} = $self->format_ccls($cd, $cd->{ccls});
 }
 
 sub after_compile {
     my ($self, $cd) = @_;
 
     setlocale(LC_ALL, $cd->{_orig_locale});
 
     if ($cd->{args}{format} eq 'msg_catalog') {
         $cd->{result} = $cd->{_msg_catalog};
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH.pm ###
 package Data::Sah::Compiler::human::TH;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::TH';
 
 sub name { undef }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $pkg = ref($self);
     $pkg =~ s/^Data::Sah::Compiler::human::TH:://;
 
     $c->add_ccl($cd, {type=>'noun', fmt=>$pkg});
 }
 
 
 sub clause_name {}
 sub clause_summary {}
 sub clause_description {}
 sub clause_comment {}
 sub clause_tags {}
 
 sub clause_prefilters {}
 sub clause_postfilters {}
 
 
 sub clause_ok {}
 
 
 sub clause_req {}
 sub clause_forbidden {}
 
 
 sub clause_default {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {expr=>1,
                       fmt => 'default value %s'});
 }
 
 sub before_clause_clause {
     my ($self, $cd) = @_;
     $cd->{CLAUSE_DO_MULTI} = 0;
 }
 
 sub before_clause_clset {
     my ($self, $cd) = @_;
     $cd->{CLAUSE_DO_MULTI} = 0;
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/Comparable.pm ###
 package Data::Sah::Compiler::human::TH::Comparable;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::Comparable';
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c = $self->compiler;
 
     my $fmt;
     if ($which eq 'is') {
         $c->add_ccl($cd, {expr=>1, multi=>1,
                           fmt => '%(modal_verb)s have the value %s'});
     } elsif ($which eq 'in') {
         $c->add_ccl($cd, {expr=>1, multi=>1,
                           fmt => '%(modal_verb)s be one of %s'});
     }
 }
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/HasElems.pm ###
 package Data::Sah::Compiler::human::TH::HasElems;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::HasElems';
 
 sub before_clause {
     my ($self_th, $which, $cd) = @_;
 }
 
 sub before_clause_len_between {
     my ($self, $cd) = @_;
     $cd->{CLAUSE_DO_MULTI} = 0;
 }
 
 sub superclause_has_elems {
     my ($self_th, $which, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
 
     if ($which eq 'len') {
         $c->add_ccl($cd, {
             expr  => 1,
             fmt   => q[length %(modal_verb)s be %s],
         });
     } elsif ($which eq 'min_len') {
         $c->add_ccl($cd, {
             expr  => 1,
             fmt   => q[length %(modal_verb)s be at least %s],
         });
     } elsif ($which eq 'max_len') {
         $c->add_ccl($cd, {
             expr  => 1,
             fmt   => q[length %(modal_verb)s be at most %s],
         });
     } elsif ($which eq 'len_between') {
         $c->add_ccl($cd, {
             fmt   => q[length %(modal_verb)s be between %s and %s],
             vals  => $cv,
         });
     } elsif ($which eq 'has') {
         $c->add_ccl($cd, {
             expr=>1, multi=>1,
             fmt => "%(modal_verb)s have %s in its elements"});
     } elsif ($which eq 'each_index') {
         $self_th->clause_each_index($cd);
     } elsif ($which eq 'each_elem') {
         $self_th->clause_each_elem($cd);
     } elsif ($which eq 'check_each_index') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'check_each_elem') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'uniq') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'exists') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/Sortable.pm ###
 package Data::Sah::Compiler::human::TH::Sortable;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::Sortable';
 
 sub before_clause_between {
     my ($self, $cd) = @_;
     $cd->{CLAUSE_DO_MULTI} = 0;
 }
 
 sub before_clause_xbetween {
     my ($self, $cd) = @_;
     $cd->{CLAUSE_DO_MULTI} = 0;
 }
 
 sub superclause_sortable {
     my ($self, $which, $cd) = @_;
     my $c = $self->compiler;
     my $cv = $cd->{cl_value};
 
     if ($which eq 'min') {
         $c->add_ccl($cd, {
             expr=>1,
             fmt => '%(modal_verb)s be at least %s',
         });
     } elsif ($which eq 'xmin') {
         $c->add_ccl($cd, {
             expr=>1,
             fmt => '%(modal_verb)s be larger than %s',
         });
     } elsif ($which eq 'max') {
         $c->add_ccl($cd, {
             expr=>1,
             fmt => '%(modal_verb)s be at most %s',
         });
     } elsif ($which eq 'xmax') {
         $c->add_ccl($cd, {
             expr=>1,
             fmt => '%(modal_verb)s be smaller than %s',
         });
     } elsif ($which eq 'between') {
         $c->add_ccl($cd, {
             fmt => '%(modal_verb)s be between %s and %s',
             vals => $cv,
         });
     } elsif ($which eq 'xbetween') {
         $c->add_ccl($cd, {
             fmt => '%(modal_verb)s be larger than %s and smaller than %s',
             vals => $cv,
         });
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/all.pm ###
 package Data::Sah::Compiler::human::TH::all;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Type::all';
 
 sub handle_type {
 }
 
 sub clause_of {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     my @result;
     my $i = 0;
     for my $cv2 (@$cv) {
         local $cd->{spath} = [@{$cd->{spath}}, $i];
         my %iargs = %{$cd->{args}};
         $iargs{outer_cd}             = $cd;
         $iargs{schema}               = $cv2;
         $iargs{schema_is_normalized} = 0;
         my $icd = $c->compile(%iargs);
         push @result, $icd->{ccls};
         $c->_add_msg_catalog($cd, $icd->{ccls});
         $i++;
     }
 
     my $can = 1;
     for my $r (@result) {
         unless (@$r == 1 && $r->[0]{type} eq 'noun') {
             $can = 0;
             last;
         }
     }
 
     my $vals;
     if ($can) {
         my $c0  = $c->_xlt($cd, '%(modal_verb)s be %s');
         my $awa = $c->_xlt($cd, 'as well as %s');
         my $wb  = $c->_xlt($cd, ' ');
         my $fmt;
         my $i = 0;
         for my $r (@result) {
             $fmt .= $i ? $wb . $awa : $c0;
             push @$vals, ref($r->[0]{text}) eq 'ARRAY' ?
                 $r->[0]{text}[0] : $r->[0]{text};
             $i++;
         }
         $c->add_ccl($cd, {
             fmt  => $fmt,
             vals => $vals,
             xlt  => 0,
             type => 'noun',
         });
     } else {
         $c->add_ccl($cd, {
             type  => 'list',
             fmt   => '%(modal_verb)s be all of the following',
             items => [
                 @result,
             ],
             vals  => [],
         });
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/any.pm ###
 package Data::Sah::Compiler::human::TH::any;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Type::any';
 
 sub handle_type {
 }
 
 sub clause_of {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     my @result;
     my $i = 0;
     for my $cv2 (@$cv) {
         local $cd->{spath} = [@{$cd->{spath}}, $i];
         my %iargs = %{$cd->{args}};
         $iargs{outer_cd}             = $cd;
         $iargs{schema}               = $cv2;
         $iargs{schema_is_normalized} = 0;
         my $icd = $c->compile(%iargs);
         push @result, $icd->{ccls};
         $i++;
     }
 
     my $can = 1;
     for my $r (@result) {
         unless (@$r == 1 && $r->[0]{type} eq 'noun') {
             $can = 0;
             last;
         }
     }
 
     my $vals;
     if ($can) {
         my $c0  = $c->_xlt($cd, '%(modal_verb)s be either %s');
         my $awa = $c->_xlt($cd, 'or %s');
         my $wb  = $c->_xlt($cd, ' ');
         my $fmt;
         my $i = 0;
         for my $r (@result) {
             $fmt .= $i ? $wb . $awa : $c0;
             push @$vals, ref($r->[0]{text}) eq 'ARRAY' ?
                 $r->[0]{text}[0] : $r->[0]{text};
             $i++;
         }
         $c->add_ccl($cd, {
             fmt  => $fmt,
             vals => $vals,
             xlt  => 0,
             type => 'noun',
         });
     } else {
         $c->add_ccl($cd, {
             type  => 'list',
             fmt   => '%(modal_verb)s be one of the following',
             items => [
                 @result,
             ],
             vals  => [],
         });
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/array.pm ###
 package Data::Sah::Compiler::human::TH::array;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Compiler::human::TH::Comparable';
 with 'Data::Sah::Compiler::human::TH::HasElems';
 with 'Data::Sah::Type::array';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => ["array", "arrays"],
         type  => 'noun',
     });
 }
 
 sub clause_each_index {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     my %iargs = %{$cd->{args}};
     $iargs{outer_cd}             = $cd;
     $iargs{schema}               = $cv;
     $iargs{schema_is_normalized} = 0;
     my $icd = $c->compile(%iargs);
 
     $c->add_ccl($cd, {
         type  => 'list',
         fmt   => 'each array subscript %(modal_verb)s be',
         items => [
             $icd->{ccls},
         ],
         vals  => [],
     });
 }
 
 sub clause_each_elem {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     my %iargs = %{$cd->{args}};
     $iargs{outer_cd}             = $cd;
     $iargs{schema}               = $cv;
     $iargs{schema_is_normalized} = 0;
     my $icd = $c->compile(%iargs);
 
     if (@{$icd->{ccls}} == 1) {
         my $c0 = $icd->{ccls}[0];
         if ($c0->{type} eq 'noun' && ref($c0->{text}) eq 'ARRAY' &&
                 @{$c0->{text}} > 1 && @{$cd->{ccls}} &&
                     $cd->{ccls}[0]{type} eq 'noun') {
             for (ref($cd->{ccls}[0]{text}) eq 'ARRAY' ?
                      @{$cd->{ccls}[0]{text}} : ($cd->{ccls}[0]{text})) {
                 my $fmt = $c->_xlt($cd, '%s of %s');
                 $_ = sprintf $fmt, $_, $c0->{text}[1];
             }
             return;
         }
     }
 
     $c->add_ccl($cd, {
         type  => 'list',
         fmt   => 'each array element %(modal_verb)s be',
         items => [
             $icd->{ccls},
         ],
         vals  => [],
     });
 }
 
 sub clause_elems {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     for my $i (0..@$cv-1) {
         local $cd->{spath} = [@{$cd->{spath}}, $i];
         my $v = $cv->[$i];
         my %iargs = %{$cd->{args}};
         $iargs{outer_cd}             = $cd;
         $iargs{schema}               = $v;
         $iargs{schema_is_normalized} = 0;
         my $icd = $c->compile(%iargs);
         $c->add_ccl($cd, {
             type  => 'list',
             fmt   => '%s %(modal_verb)s be',
             vals  => [
                 $c->_ordinate($cd, $i+1, $c->_xlt($cd, "element")),
             ],
             items => [ $icd->{ccls} ],
         });
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/bool.pm ###
 package Data::Sah::Compiler::human::TH::bool;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Compiler::human::TH::Comparable';
 with 'Data::Sah::Compiler::human::TH::Sortable';
 with 'Data::Sah::Type::bool';
 
 sub name { "boolean value" }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => ["boolean value", "boolean values"],
         type  => 'noun',
     });
 }
 
 sub before_clause_is_true {
     my ($self, $cd) = @_;
     $cd->{CLAUSE_DO_MULTI} = 0;
 }
 
 sub clause_is_true {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     $c->add_ccl($cd, {
         fmt   => $cv ? q[%(modal_verb)s be true] : q[%(modal_verb)s be false],
     });
 }
 
 sub clause_is_re {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     $c->add_ccl($cd, {
         fmt   => q[%(modal_verb)s be a regex pattern],
     });
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/buf.pm ###
 package Data::Sah::Compiler::human::TH::buf;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH::str';
 
 sub name { "buffer" }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => ["buffer", "buffers"],
         type  => 'noun',
     });
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/cistr.pm ###
 package Data::Sah::Compiler::human::TH::cistr;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH::str';
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/code.pm ###
 package Data::Sah::Compiler::human::TH::code;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Type::code';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => ["code", "codes"],
         type  => 'noun',
     });
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/date.pm ###
 package Data::Sah::Compiler::human::TH::date;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Compiler::human::TH::Comparable';
 with 'Data::Sah::Compiler::human::TH::Sortable';
 with 'Data::Sah::Type::date';
 
 sub name { "date" }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {type=>'noun', fmt => ["date", "dates"]});
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/duration.pm ###
 package Data::Sah::Compiler::human::TH::duration;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Type::duration';
 
 sub name { "duration" }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {type=>'noun', fmt => ["duration", "durations"]});
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/float.pm ###
 package Data::Sah::Compiler::human::TH::float;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Compiler::human::TH::Comparable';
 with 'Data::Sah::Compiler::human::TH::Sortable';
 with 'Data::Sah::Type::float';
 
 sub name { "decimal number" }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {
         type=>'noun',
         fmt => ["decimal number", "decimal numbers"],
     });
 }
 
 sub clause_is_nan {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $cv = $cd->{cl_value};
     if ($cd->{cl_is_expr}) {
         $c->add_ccl($cd, {});
     } else {
         $c->add_ccl($cd, {
             fmt => $cv ?
                 q[%(modal_verb)s be a NaN] :
                     q[%(modal_verb_neg)s be a NaN],
         });
     }
 }
 
 sub clause_is_inf {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $cv = $cd->{cl_value};
     if ($cd->{cl_is_expr}) {
         $c->add_ccl($cd, {});
     } else {
         $c->add_ccl($cd, {
             fmt => $cv ?
                 q[%(modal_verb)s an infinity] :
                     q[%(modal_verb_neg)s an infinity],
         });
     }
 }
 
 sub clause_is_pos_inf {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $cv = $cd->{cl_value};
     if ($cd->{cl_is_expr}) {
         $c->add_ccl($cd, {});
     } else {
         $c->add_ccl($cd, {
             fmt => $cv ?
                 q[%(modal_verb)s a positive infinity] :
                     q[%(modal_verb_neg)s a positive infinity],
         });
     }
 }
 
 sub clause_is_neg_inf {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $cv = $cd->{cl_value};
     if ($cd->{cl_is_expr}) {
         $c->add_ccl($cd, {});
     } else {
         $c->add_ccl($cd, {
             fmt => $cv ?
                 q[%(modal_verb)s a negative infinity] :
                     q[%(modal_verb_neg)s a negative infinity],
         });
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/hash.pm ###
 package Data::Sah::Compiler::human::TH::hash;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Compiler::human::TH::Comparable';
 with 'Data::Sah::Compiler::human::TH::HasElems';
 with 'Data::Sah::Type::hash';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => ["hash", "hashes"],
         type  => 'noun',
     });
 }
 
 sub clause_has {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     $c->add_ccl($cd, {
         expr=>1, multi=>1,
         fmt => "%(modal_verb)s have %s in its %(field)s values"});
 }
 
 sub clause_each_index {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     my %iargs = %{$cd->{args}};
     $iargs{outer_cd}             = $cd;
     $iargs{schema}               = $cv;
     $iargs{schema_is_normalized} = 0;
     my $icd = $c->compile(%iargs);
 
     $c->add_ccl($cd, {
         type  => 'list',
         fmt   => '%(field)s name %(modal_verb)s be',
         items => [
             $icd->{ccls},
         ],
         vals  => [],
     });
 }
 
 sub clause_each_elem {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     my %iargs = %{$cd->{args}};
     $iargs{outer_cd}             = $cd;
     $iargs{schema}               = $cv;
     $iargs{schema_is_normalized} = 0;
     my $icd = $c->compile(%iargs);
 
     $c->add_ccl($cd, {
         type  => 'list',
         fmt   => 'each %(field)s %(modal_verb)s be',
         items => [
             $icd->{ccls},
         ],
         vals  => [],
     });
 }
 
 sub clause_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     for my $k (sort keys %$cv) {
         local $cd->{spath} = [@{$cd->{spath}}, $k];
         my $v = $cv->{$k};
         my %iargs = %{$cd->{args}};
         $iargs{outer_cd}             = $cd;
         $iargs{schema}               = $v;
         $iargs{schema_is_normalized} = 0;
         my $icd = $c->compile(%iargs);
         $c->add_ccl($cd, {
             type  => 'list',
             fmt   => '%(field)s %s %(modal_verb)s be',
             vals  => [$k],
             items => [ $icd->{ccls} ],
         });
     }
 }
 
 sub clause_re_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     for my $k (sort keys %$cv) {
         local $cd->{spath} = [@{$cd->{spath}}, $k];
         my $v = $cv->{$k};
         my %iargs = %{$cd->{args}};
         $iargs{outer_cd}             = $cd;
         $iargs{schema}               = $v;
         $iargs{schema_is_normalized} = 0;
         my $icd = $c->compile(%iargs);
         $c->add_ccl($cd, {
             type  => 'list',
             fmt   => '%(fields)s whose names match regex pattern %s %(modal_verb)s be',
             vals  => [$k],
             items => [ $icd->{ccls} ],
         });
     }
 }
 
 sub clause_req_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => q[%(modal_verb)s have required %(fields)s %s],
         expr  => 1,
     });
 }
 
 sub clause_allowed_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => q[%(modal_verb)s only have these allowed %(fields)s %s],
         expr  => 1,
     });
 }
 
 sub clause_allowed_keys_re {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => q[%(modal_verb)s only have %(fields)s matching regex pattern %s],
         expr  => 1,
     });
 }
 
 sub clause_forbidden_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => q[%(modal_verb_neg)s have these forbidden %(fields)s %s],
         expr  => 1,
     });
 }
 
 sub clause_forbidden_keys_re {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => q[%(modal_verb_neg)s have %(fields)s matching regex pattern %s],
         expr  => 1,
     });
 }
 
 sub clause_choose_one_key {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     my $multi = $cd->{cl_is_multi};
     $cd->{cl_is_multi} = 0;
 
     my @ccls;
     for my $cv ($multi ? @{ $cd->{cl_value} } : ($cd->{cl_value})) {
         push @ccls, {
             fmt   => q[%(modal_verb)s contain at most one of these %(fields)s %s],
             vals  => [$cv],
         };
     }
     $c->add_ccl($cd, @ccls);
 }
 
 sub clause_choose_all_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     my $multi = $cd->{cl_is_multi};
     $cd->{cl_is_multi} = 0;
 
     my @ccls;
     for my $cv ($multi ? @{ $cd->{cl_value} } : ($cd->{cl_value})) {
         push @ccls, {
             fmt   => q[%(modal_verb)s contain either none or all of these %(fields)s %s],
             vals  => [$cv],
         };
     }
     $c->add_ccl($cd, @ccls);
 }
 
 sub clause_req_one_key {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     my $multi = $cd->{cl_is_multi};
     $cd->{cl_is_multi} = 0;
 
     my @ccls;
     for my $cv ($multi ? @{ $cd->{cl_value} } : ($cd->{cl_value})) {
         push @ccls, {
             fmt   => q[%(modal_verb)s contain exactly one of these %(fields)s %s],
             vals  => [$cv],
         };
     }
     $c->add_ccl($cd, @ccls);
 }
 
 sub clause_dep_any {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     my $multi = $cd->{cl_is_multi};
     $cd->{cl_is_multi} = 0;
 
     my @ccls;
     for my $cv ($multi ? @{ $cd->{cl_value} } : ($cd->{cl_value})) {
         if (@{ $cv->[1] } == 1) {
             push @ccls, {
                 fmt   => q[%(field)s %2$s %(modal_verb)s be present before %(field)s %1$s can be present],
                 vals  => [$cv->[0], $cv->[1][0]],
             };
         } else {
             push @ccls, {
                 fmt   => q[one of %(fields)s %2$s %(modal_verb)s be present before %(field)s %1$s can be present],
                 vals  => $cv,
                 multi => 0,
             };
         }
     }
     $c->add_ccl($cd, @ccls);
 }
 
 sub clause_dep_all {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     my $multi = $cd->{cl_is_multi};
     $cd->{cl_is_multi} = 0;
 
     my @ccls;
     for my $cv ($multi ? @{ $cd->{cl_value} } : ($cd->{cl_value})) {
         if (@{ $cv->[1] } == 1) {
             push @ccls, {
                 fmt   => q[%(field)s %2$s %(modal_verb)s be present before %(field)s %1$s can be present],
                 vals  => [$cv->[0], $cv->[1][0]],
             };
         } else {
             push @ccls, {
                 fmt   => q[all of %(fields)s %2$s %(modal_verb)s be present before %(field)s %1$s can be present],
                 vals  => $cv,
             };
         }
     }
     $c->add_ccl($cd, @ccls);
 }
 
 sub clause_req_dep_any {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     my $multi = $cd->{cl_is_multi};
     $cd->{cl_is_multi} = 0;
 
     my @ccls;
     for my $cv ($multi ? @{ $cd->{cl_value} } : ($cd->{cl_value})) {
         if (@{ $cv->[1] } == 1) {
             push @ccls, {
                 fmt   => q[%(field)s %1$s %(modal_verb)s be present when %(field)s %2$s is present],
                 vals  => [$cv->[0], $cv->[1][0]],
             };
         } else {
             push @ccls, {
                 fmt   => q[%(field)s %1$s %(modal_verb)s be present when one of %(fields)s %2$s is present],
                 vals  => $cv,
             };
         }
     }
     $c->add_ccl($cd, @ccls);
 }
 
 sub clause_req_dep_all {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
 
     my $multi = $cd->{cl_is_multi};
     $cd->{cl_is_multi} = 0;
 
     my @ccls;
     for my $cv ($multi ? @{ $cd->{cl_value} } : ($cd->{cl_value})) {
         if (@{ $cv->[1] } == 1) {
             push @ccls, {
                 fmt   => q[%(field)s %1$s %(modal_verb)s be present when %(field)s %2$s is present],
                 vals  => [$cv->[0], $cv->[1][0]],
             };
         } else {
             push @ccls, {
                 fmt   => q[%(field)s %1$s %(modal_verb)s be present when all of %(fields)s %2$s are present],
                 vals  => $cv,
             };
         }
     }
     $c->add_ccl($cd, @ccls);
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/int.pm ###
 package Data::Sah::Compiler::human::TH::int;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH::num';
 with 'Data::Sah::Type::int';
 
 sub name { "integer" }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {
         type  => 'noun',
         fmt   => ["integer", "integers"],
     });
 }
 
 sub clause_div_by {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     if (!$cd->{cl_is_multi} && !$cd->{cl_is_expr} &&
             $cv == 2) {
         $c->add_ccl($cd, {
             fmt   => q[%(modal_verb)s be even],
         });
         return;
     }
 
     $c->add_ccl($cd, {
         fmt   => q[%(modal_verb)s be divisible by %s],
         expr  => 1,
     });
 }
 
 sub clause_mod {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     if (!$cd->{cl_is_multi} && !$cd->{cl_is_expr}) {
         if ($cv->[0] == 2 && $cv->[1] == 0) {
             $c->add_ccl($cd, {
                 fmt   => q[%(modal_verb)s be even],
             });
             return;
         } elsif ($cv->[0] == 2 && $cv->[1] == 1) {
             $c->add_ccl($cd, {
                 fmt   => q[%(modal_verb)s be odd],
             });
             return;
         }
     }
 
     my @ccls;
     for my $cv ($cd->{cl_is_multi} ? @{ $cd->{cl_value} } : ($cd->{cl_value})) {
         push @ccls, {
             fmt  => q[%(modal_verb)s leave a remainder of %2$s when divided by %1$s],
             vals => $cv,
         };
     }
     $c->add_ccl($cd, @ccls);
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/num.pm ###
 package Data::Sah::Compiler::human::TH::num;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Compiler::human::TH::Comparable';
 with 'Data::Sah::Compiler::human::TH::Sortable';
 with 'Data::Sah::Type::num';
 
 sub name { "number" }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {type=>'noun', fmt => ["number", "numbers"]});
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/obj.pm ###
 package Data::Sah::Compiler::human::TH::obj;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Type::obj';
 
 sub name { "object" }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => ["object", "objects"],
         type  => 'noun',
     });
 }
 
 sub clause_can {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     $c->add_ccl($cd, {
         fmt   => q[%(modal_verb)s have method(s) %s],
     });
 }
 
 sub clause_isa {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     $c->add_ccl($cd, {
         fmt   => q[%(modal_verb)s be subclass of %s],
     });
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/re.pm ###
 package Data::Sah::Compiler::human::TH::re;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Type::re';
 
 sub name { "regex pattern" }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => ["regex pattern", "regex patterns"],
         type  => 'noun',
     });
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/str.pm ###
 package Data::Sah::Compiler::human::TH::str;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Compiler::human::TH::Sortable';
 with 'Data::Sah::Compiler::human::TH::Comparable';
 with 'Data::Sah::Compiler::human::TH::HasElems';
 with 'Data::Sah::Type::str';
 
 sub name { "text" }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => ["text", "texts"],
         type  => 'noun',
     });
 }
 
 sub clause_each_index {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     my %iargs = %{$cd->{args}};
     $iargs{outer_cd}             = $cd;
     $iargs{schema}               = $cv;
     $iargs{schema_is_normalized} = 0;
     my $icd = $c->compile(%iargs);
 
     $c->add_ccl($cd, {
         type  => 'list',
         fmt   => 'each subscript of text %(modal_verb)s be',
         items => [
             $icd->{ccls},
         ],
         vals  => [],
     });
 }
 
 sub clause_each_elem {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     my %iargs = %{$cd->{args}};
     $iargs{outer_cd}             = $cd;
     $iargs{schema}               = $cv;
     $iargs{schema_is_normalized} = 0;
     my $icd = $c->compile(%iargs);
 
     $c->add_ccl($cd, {
         type  => 'list',
         fmt   => 'each character of the text %(modal_verb)s be',
         items => [
             $icd->{ccls},
         ],
         vals  => [],
     });
 }
 
 sub clause_encoding {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     $c->_die($cd, "Only 'utf8' encoding is currently supported")
         unless $cv eq 'utf8';
 }
 
 sub clause_match {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     $c->add_ccl($cd, {
         fmt   => q[%(modal_verb)s match regex pattern %s],
     });
 }
 
 sub clause_is_re {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
 
     $c->add_ccl($cd, {
         fmt   => q[%(modal_verb)s be a regex pattern],
     });
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/human/TH/undef.pm ###
 package Data::Sah::Compiler::human::TH::undef;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::human::TH';
 with 'Data::Sah::Type::undef';
 
 sub name { "undefined value" }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     $c->add_ccl($cd, {
         fmt   => ["undefined value", "undefined values"],
         type  => 'noun',
     });
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js.pm ###
 package Data::Sah::Compiler::js;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use String::Indent ();
 
 extends 'Data::Sah::Compiler::Prog';
 
 sub BUILD {
     my ($self, $args) = @_;
 
     $self->comment_style('cpp');
     $self->indent_character(" " x 4);
     $self->var_sigil("");
     $self->concat_op("+");
 }
 
 sub name { "js" }
 
 sub expr {
     my ($self, $expr) = @_;
     $self->expr_compiler->js($expr);
 }
 
 sub literal {
     my ($self, $val) = @_;
 
     state $json = do {
         require JSON;
         JSON->new->allow_nonref;
     };
 
     state $cleanser = do {
         require Data::Clean::JSON;
         Data::Clean::JSON->get_cleanser;
     };
 
     $json->encode($cleanser->clone_and_clean($val));
 }
 
 sub compile {
     my ($self, %args) = @_;
 
 
 
     $self->SUPER::compile(%args);
 }
 
 sub true { "true" }
 
 sub false { "false" }
 
 sub expr_defined {
     my ($self, $t) = @_;
     "!($t === undefined || $t === null)";
 }
 
 sub expr_array_subscript {
     my ($self, $at, $idxt) = @_;
     "$at\[$idxt]";
 }
 
 sub expr_last_elem {
     my ($self, $at, $idxt) = @_;
     "$at\[($at).length-1]";
 }
 
 sub expr_array_0_nmin1 {
     my ($self, $n) = @_;
     "Array($n).join().split(',').map(function(e,i){return i})";
 }
 
 sub expr_array_1_n {
     my ($self, $n) = @_;
     "Array($n).join().split(',').map(function(e,i){return i+1})";
 }
 
 sub expr_push {
     my ($self, $at, $elt) = @_;
     "($at).push($elt)";
 }
 
 sub expr_pop {
     my ($self, $at, $elt) = @_;
     "($at).pop()";
 }
 
 sub expr_push_and_pop_dpath_between_expr {
     my ($self, $et) = @_;
     join(
         "",
         "[",
         $self->expr_push('_sahv_dpath', $self->literal(undef)), ", ", 
         $self->enclose_paren($et), ", ", 
         $self->expr_pop('_sahv_dpath'), 
         "][1]",
     );
 }
 
 sub expr_prefix_dpath {
     my ($self, $t) = @_;
     '(_sahv_dpath.length ? "@" + _sahv_dpath.join("/") + ": " : "") + ' . $t;
 }
 
 sub expr_setif {
     my ($self, $l, $r) = @_;
     "$l = " . $self->expr_defined($l) . " ? $l : $r";
 }
 
 sub expr_set_err_str {
     my ($self, $et, $err_expr) = @_;
     $self->expr_setif($et, $err_expr);
 }
 
 sub expr_set_err_full {
     my ($self, $et, $k, $err_expr) = @_;
     join(
         "",
         "(",
         $self->expr_setif("$et\['$k']", "{}"),
         ",",
         $self->expr_setif("$et\['$k'][_sahv_dpath.join('/')]", $err_expr),
         ")",
     );
 }
 
 sub expr_reset_err_str {
     my ($self, $et, $err_expr) = @_;
     "($et = null, true)";
 }
 
 sub expr_reset_err_full {
     my ($self, $et) = @_;
     join(
         "",
         "(",
         $self->expr_setif("$et\['errors']", "{}"),
         ",",
         "delete($et\['errors'][_sahv_dpath.join('/')])",
         ")",
     );
 }
 
 sub expr_log {
     my ($self, $cd, $ccl) = @_;
     "";
 }
 
 sub expr_block {
     my ($self, $code) = @_;
     join(
         "",
         "(function() {\n",
         String::Indent::indent(
             $self->indent_character,
             $code,
         ),
         "})()",
     );
 }
 
 sub block_uses_sub { 1 }
 
 sub stmt_declare_local_var {
     my $self = shift;
     my $v = shift;
     if (@_) {
         "var $v = $_[0];";
     } else {
         "var $v;";
     }
 }
 
 sub expr_anon_sub {
     my ($self, $args, $code) = @_;
     join(
         "",
         "function(".join(", ", @$args).") {\n",
         String::Indent::indent(
             $self->indent_character,
             $code,
         ),
         "}"
     );
 }
 
 sub stmt_require_module {
     my ($self, $mod, $cd) = @_;
     '';
 }
 
 sub stmt_require_log_module {
     my ($self, $mod) = @_;
     '';
 }
 
 sub stmt_return {
     my $self = shift;
     if (@_) {
         "return($_[0]);";
     } else {
         'return;';
     }
 }
 
 sub expr_validator_sub {
     my ($self, %args) = @_;
 
     $args{data_term} = 'data';
     $self->SUPER::expr_validator_sub(%args);
 }
 
 sub _str2reliteral {
     my ($self, $cd, $str) = @_;
 
     my $re;
     if (ref($str) eq 'Regexp') {
         $re = "$str";
     } else {
         eval { qr/$str/ };
         $self->_die($cd, "Invalid regex $str: $@") if $@;
         $re = $str;
     }
 
     $re = "$re";
     $re =~ s!/!\\/!g;
     "/$re/";
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH.pm ###
 package Data::Sah::Compiler::js::TH;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 
 extends 'Data::Sah::Compiler::Prog::TH';
 
 sub gen_each {
     my ($self, $cd, $indices_expr, $data_name, $data_term, $code_at_sub_begin) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $dt = $cd->{data_term};
 
     local $cd->{_subdata_level} = $cd->{_subdata_level} + 1;
     my $use_dpath = $cd->{args}{return_type} ne 'bool';
 
     my %iargs = %{$cd->{args}};
     $iargs{outer_cd}             = $cd;
     $iargs{data_name}            = $data_name,
     $iargs{data_term}            = $data_term,
     $iargs{schema}               = $cv;
     $iargs{schema_is_normalized} = 0;
     $iargs{indent_level}++;
     my $icd = $c->compile(%iargs);
     my @code = (
         "(", $indices_expr, ").every(function(_sahv_idx){", ($code_at_sub_begin // ''), " return(\n",
         ($c->indent_str($cd), "(_sahv_dpath[_sahv_dpath.length ? _sahv_dpath.length-1 : 0] = _sahv_idx),\n") x !!$use_dpath,
         $icd->{result}, "\n",
         $c->indent_str($icd), ")})",
     );
     $c->add_ccl($cd, join("", @code), {subdata=>1});
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/all.pm ###
 package Data::Sah::Compiler::js::TH::all;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 
 use parent (
     'Data::Sah::Compiler::js::TH',
     'Data::Sah::Compiler::Prog::TH::all',
 );
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/any.pm ###
 package Data::Sah::Compiler::js::TH::any;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 
 
 use parent (
     'Data::Sah::Compiler::js::TH',
     'Data::Sah::Compiler::Prog::TH::any',
 );
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/array.pm ###
 package Data::Sah::Compiler::js::TH::array;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH';
 with 'Data::Sah::Type::array';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "$dt instanceof Array";
 }
 
 my $STR = "JSON.stringify";
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "$STR($dt) == $STR($ct)");
     } elsif ($which eq 'in') {
         $c->add_ccl(
             $cd,
             "!($ct).every(function(x){return $STR(x) != $STR($dt) })");
     }
 }
 
 sub superclause_has_elems {
     my ($self_th, $which, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'len') {
         $c->add_ccl($cd, "($dt).length == $ct");
     } elsif ($which eq 'min_len') {
         $c->add_ccl($cd, "($dt).length >= $ct");
     } elsif ($which eq 'max_len') {
         $c->add_ccl($cd, "($dt).length <= $ct");
     } elsif ($which eq 'len_between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl(
                 $cd, "($dt).length >= $ct\->[0] && ($dt).length >= $ct\->[1]");
         } else {
             $c->add_ccl(
                 $cd, "($dt).length >= $cv->[0] && ($dt).length <= $cv->[1]");
         }
     } elsif ($which eq 'has') {
         $c->add_ccl(
             $cd,
             "($dt).map(function(x){return $STR(x)}).indexOf($STR($ct)) > -1");
     } elsif ($which eq 'each_index') {
         $self_th->gen_each($cd,
                            $c->expr_array_0_nmin1("($dt).length"), '_sahv_idx', '_sahv_idx');
     } elsif ($which eq 'each_elem') {
         $self_th->gen_each($cd,
                            $c->expr_array_0_nmin1("($dt).length"), '_sahv_idx', "$dt\[_sahv_idx]");
     } elsif ($which eq 'check_each_index') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'check_each_elem') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'uniq') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'exists') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     }
 }
 
 sub clause_elems {
     my ($self_th, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $dt = $cd->{data_term};
 
     local $cd->{_subdata_level} = $cd->{_subdata_level} + 1;
     my $use_dpath = $cd->{args}{return_type} ne 'bool';
 
     my $jccl;
     {
         local $cd->{ccls} = [];
 
         my $cdef = $cd->{clset}{"elems.create_default"} // 1;
         delete $cd->{uclset}{"elems.create_default"};
 
         for my $i (0..@$cv-1) {
             local $cd->{spath} = [@{$cd->{spath}}, $i];
             my $sch = $c->main->normalize_schema($cv->[$i]);
             my $edt = "$dt\[$i]";
             my %iargs = %{$cd->{args}};
             $iargs{outer_cd}             = $cd;
             $iargs{data_name}            = "$cd->{args}{data_name}_$i";
             $iargs{data_term}            = $edt;
             $iargs{schema}               = $sch;
             $iargs{schema_is_normalized} = 1;
             $iargs{indent_level}++;
             my $icd = $c->compile(%iargs);
             my @code = (
                 ($c->indent_str($cd), "(_sahv_dpath[-1] = $i),\n") x !!$use_dpath,
                 $icd->{result}, "\n",
             );
             my $ires = join("", @code);
             local $cd->{_debug_ccl_note} = "elem: $i";
             if ($cdef && defined($sch->[1]{default})) {
                 $c->add_ccl($cd, $ires);
             } else {
                 $c->add_ccl($cd, "($dt).length < ".($i+1)." || ($ires)");
             }
         }
         $jccl = $c->join_ccls(
             $cd, $cd->{ccls}, {err_msg => ''});
     }
     $c->add_ccl($cd, $jccl, {subdata=>1});
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/bool.pm ###
 package Data::Sah::Compiler::js::TH::bool;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH';
 with 'Data::Sah::Type::bool';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "typeof($dt)=='boolean' || typeof($dt)=='number' || typeof($dt)=='string'";
 }
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "!!($dt) == !!($ct)");
     } elsif ($which eq 'in') {
         $c->add_ccl($cd, "($ct).map(function(x){return !!x}).indexOf(!!($dt)) > -1");
     }
 }
 
 sub superclause_sortable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'min') {
         $c->add_ccl($cd, "!!($dt) >= !!($ct)");
     } elsif ($which eq 'xmin') {
         $c->add_ccl($cd, "!!($dt) > !!($ct)");
     } elsif ($which eq 'max') {
         $c->add_ccl($cd, "!!($dt) <= !!($ct)");
     } elsif ($which eq 'xmax') {
         $c->add_ccl($cd, "!!($dt) < !!($ct)");
     } elsif ($which eq 'between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "!!($dt) >= !!($ct\->[0]) && ".
                             "!!($dt) <= !!($ct\->[1])");
         } else {
             $c->add_ccl($cd, "!!($dt) >= !!($cv->[0]) && ".
                             "!!($dt) <= !!($cv->[1])");
         }
     } elsif ($which eq 'xbetween') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "!!($dt) > !!($ct\->[0]) && ".
                             "!!($dt) < !!($ct\->[1])");
         } else {
             $c->add_ccl($cd, "!!($dt) > !!($cv->[0]) && ".
                             "!!($dt) < !!($cv->[1])");
         }
     }
 }
 
 sub clause_is_true {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl($cd, "$ct ? !!($dt) : !(".$c->expr_defined($ct).") ? true : !($dt)");
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/buf.pm ###
 package Data::Sah::Compiler::js::TH::buf;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH::str';
 with 'Data::Sah::Type::buf';
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/cistr.pm ###
 package Data::Sah::Compiler::js::TH::cistr;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH::str';
 with 'Data::Sah::Type::cistr';
 
 sub before_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
 
     $self->set_tmp_data_term($cd, "typeof($dt)=='number' ? ''+$dt : typeof($dt)=='string' ? ($dt).toLowerCase() : $dt");
 }
 
 sub after_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $self->restore_data_term($cd);
 }
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "$dt == ($ct).toLowerCase()");
     } elsif ($which eq 'in') {
         $c->add_ccl($cd, "($ct).map(function(x) { return x.toLowerCase() }).indexOf($dt) > -1");
     }
 }
 
 sub superclause_sortable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'min') {
         $c->add_ccl($cd, "$dt >= ($ct).toLowerCase()");
     } elsif ($which eq 'xmin') {
         $c->add_ccl($cd, "$dt > ($ct).toLowerCase()");
     } elsif ($which eq 'max') {
         $c->add_ccl($cd, "$dt <= ($ct).toLowerCase()");
     } elsif ($which eq 'xmax') {
         $c->add_ccl($cd, "$dt < ($ct).toLowerCase()");
     } elsif ($which eq 'between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt >= (($ct)[0]).toLowerCase() && ".
                             "$dt <= (($ct)[1]).toLowerCase()");
         } else {
             $c->add_ccl($cd, "$dt >= ".$c->literal(lc $cv->[0]).
                             " && $dt <= ".$c->literal(lc $cv->[1]));
         }
     } elsif ($which eq 'xbetween') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt > (($ct)[0]).toLowerCase() && ".
                             "$dt < (($ct)[1]).toLowerCase()");
         } else {
             $c->add_ccl($cd, "$dt > ".$c->literal(lc $cv->[0]).
                             " && $dt < ".$c->literal(lc $cv->[1]));
         }
     }
 }
 
 sub superclause_has_elems {
     my ($self_th, $which, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'has') {
         $c->add_ccl($cd, "($dt).indexOf(($ct).toLowerCase()) > -1");
     } else {
         $self_th->SUPER::superclause_has_elems($which, $cd);
     }
 }
 
 sub clause_match {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     my $re;
     if ($cd->{cl_is_expr}) {
         $re = $ct;
     } else {
         $re = $c->_str2reliteral($cd, $cv);
     }
 
     $c->add_ccl($cd, join(
         "",
         "(function(){ ",
         "var _sahv_match = true; ",
         "try { _sahv_match = ($dt).match(RegExp($re)) } catch(e) { if (e.name=='SyntaxError') _sahv_match = false } ",
         ($cd->{cl_is_expr} ?
              "return _sahv_match == !!($ct);" :
                  "return ".($cv ? '':'!')."!!_sahv_match;"),
         "} )()",
     ));
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/code.pm ###
 package Data::Sah::Compiler::js::TH::code;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH';
 with 'Data::Sah::Type::code';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "typeof($dt)=='function'";
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/date.pm ###
 package Data::Sah::Compiler::js::TH::date;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 use Scalar::Util qw(blessed looks_like_number);
 
 extends 'Data::Sah::Compiler::js::TH';
 with 'Data::Sah::Type::date';
 
 my $epoch_low  = 10**8;
 my $epoch_high = 2**31;
 
 
 sub expr_coerce_term {
     my ($self, $cd, $t) = @_;
 
     join(
         '',
         "(",
         "($t instanceof Date) ? $t : ",
         "typeof($t)=='number' ? (new Date($t * 1000)) : ",
         "parseFloat($t)==$t   ? (new Date(parseFloat($t)) * 1000) : ",
         "(new Date($t))",
         ")",
     );
 }
 
 sub expr_coerce_value {
     my ($self, $cd, $v) = @_;
 
     if (blessed($v) && $v->isa('DateTime')) {
         return join(
             '',
             "(new Date(",
             $v->year, ",",
             $v->month, ",",
             $v->day, ",",
             $v->hour, ",",
             $v->minute, ",",
             $v->second, ",",
             $v->millisecond,
             "))",
         );
     } elsif (looks_like_number($v) && $v >= 10**8 && $v <= 2**31) {
         return "(new Date($v*1000))";
     } elsif ($v =~ /\A([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})Z\z/) {
         require DateTime;
         eval { DateTime->new(year=>$1, month=>$2, day=>$3,
                              hour=>$4, minute=>$5, second=>$6,
                              time_zone=>'UTC') ; 1 }
             or die "Invalid date literal '$v': $@";
         return "(new Date(\"$v\"))";
     } elsif ($v =~ /\A([0-9]{4})-([0-9]{2})-([0-9]{2})\z/) {
         require DateTime;
         eval { DateTime->new(year=>$1, month=>$2, day=>$3) ; 1 }
             or die "Invalid date literal '$v': $@";
         return "(new Date(\"$v\"))";
     } else {
         die "Invalid date literal '$v'";
     }
 }
 
 sub handle_type {
     my ($self, $cd) = @_;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = join(
         '',
         "(",
         "typeof($dt)=='number' ? ($dt >= $epoch_low && $dt <= $epoch_high) : ",
         "parseFloat($dt)==$dt ? (parseFloat($dt) >= $epoch_low && parseFloat($dt) <= $epoch_high) : ",
         "!isNaN((new Date($dt)).getYear())",
         ")",
     );
 }
 
 sub before_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
 
     $self->set_tmp_data_term($cd, $self->expr_coerce_term($cd, $dt));
 }
 
 sub after_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $self->restore_data_term($cd);
 }
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         if ($cd->{cl_is_expr}) {
             $ct = $self->expr_coerce_term($cd, $ct);
         } else {
             $ct = $self->expr_coerce_value($cd, $cv);
         }
         $c->add_ccl($cd, "+($dt) === +($ct)");
     } elsif ($which eq 'in') {
         $c->add_module('List::Util');
         if ($cd->{cl_is_expr}) {
             $c->_die($cd, "date's in clause with expression not yet supported");
         }
         $ct = '['.join(', ', map { "+(".$self->expr_coerce_value($cd, $_).")" } @$ct).']';
         $c->add_ccl($cd, "($ct).indexOf(+($dt)) > -1");
     }
 }
 
 sub superclause_sortable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->_die($cd, "date's comparison with expression not yet supported");
     }
 
     if ($which eq 'min') {
         $c->add_ccl($cd, "+($dt) >= +(".$self->expr_coerce_value($cd, $cv).")");
     } elsif ($which eq 'xmin') {
         $c->add_ccl($cd, "+($dt) > +(".$self->expr_coerce_value($cd, $cv).")");
     } elsif ($which eq 'max') {
         $c->add_ccl($cd, "+($dt) <= +(".$self->expr_coerce_value($cd, $cv).")");
     } elsif ($which eq 'xmax') {
         $c->add_ccl($cd, "+($dt) < +(".$self->expr_coerce_value($cd, $cv).")");
     } elsif ($which eq 'between') {
         $c->add_ccl($cd, "+($dt) >= +(".$self->expr_coerce_value($cd, $cv->[0]).") && ".
                         "+($dt) <= +(".$self->expr_coerce_value($cd, $cv->[1]).")");
     } elsif ($which eq 'xbetween') {
         $c->add_ccl($cd, "+($dt) > +(".$self->expr_coerce_value($cd, $cv->[0]).") && ".
                         "+($dt) < +(".$self->expr_coerce_value($cd, $cv->[1]).")");
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/float.pm ###
 package Data::Sah::Compiler::js::TH::float;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH::num';
 with 'Data::Sah::Type::float';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $cd->{_ccl_check_type} = "(typeof($dt)=='number' || parseFloat($dt)==$dt)";
 }
 
 sub clause_is_nan {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->add_ccl(
             $cd,
             join(
                 "",
                 "$ct ? isNaN($dt) : ",
                 $self->expr_defined($ct), " ? !isNaN($dt) : true",
             )
         );
     } else {
         if ($cd->{cl_value}) {
             $c->add_ccl($cd, "isNaN($dt)");
         } elsif (defined $cd->{cl_value}) {
             $c->add_ccl($cd, "!isNaN($dt)");
         }
     }
 }
 
 sub clause_is_pos_inf {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->add_ccl(
             $cd,
             join(
                 "",
                 "$ct ? $dt == Infinity : ",
                 $self->expr_defined($ct), " ? $dt != Infinity : true",
             )
         );
     } else {
         if ($cd->{cl_value}) {
             $c->add_ccl($cd, "$dt == Infinity");
         } elsif (defined $cd->{cl_value}) {
             $c->add_ccl($cd, "$dt != Infinity");
         }
     }
 }
 
 sub clause_is_neg_inf {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->add_ccl(
             $cd,
             join(
                 "",
                 "$ct ? $dt == -Infinity : ",
                 $self->expr_defined($ct), " ? $dt != -Infinity : true",
             )
         );
     } else {
         if ($cd->{cl_value}) {
             $c->add_ccl($cd, "$dt == -Infinity");
         } elsif (defined $cd->{cl_value}) {
             $c->add_ccl($cd, "$dt != -Infinity");
         }
     }
 }
 
 sub clause_is_inf {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->add_ccl(
             $cd,
             join(
                 "",
                 "$ct ? Math.abs($dt) == Infinity : ",
                 $self->expr_defined($ct), " ? Math.abs($dt) != Infinity : true",
             )
         );
     } else {
         if ($cd->{cl_value}) {
             $c->add_ccl($cd, "Math.abs($dt) == Infinity");
         } elsif (defined $cd->{cl_value}) {
             $c->add_ccl($cd, "Math.abs($dt) != Infinity");
         }
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/hash.pm ###
 package Data::Sah::Compiler::js::TH::hash;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH';
 with 'Data::Sah::Type::hash';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "typeof($dt)=='object' && !($dt instanceof Array)";
 }
 
 my $STR = "JSON.stringify";
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "$STR($dt) == $STR($ct)");
     } elsif ($which eq 'in') {
         $c->add_ccl(
             $cd,
             "!($ct).every(function(x){return $STR(x) != $STR($dt) })");
     }
 }
 
 sub superclause_has_elems {
     my ($self_th, $which, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
 
     if ($which eq 'len') {
         $c->add_ccl($cd, "Object.keys($dt).length == $ct");
     } elsif ($which eq 'min_len') {
         $c->add_ccl($cd, "Object.keys($dt).length >= $ct");
     } elsif ($which eq 'max_len') {
         $c->add_ccl($cd, "Object.keys($dt).length <= $ct");
     } elsif ($which eq 'len_between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl(
                 $cd, "Object.keys($dt).length >= $ct\->[0] && ".
                     "Object.keys($dt).length >= $ct\->[1]");
         } else {
             $c->add_ccl(
                 $cd, "Object.keys($dt).length >= $cv->[0] && ".
                     "Object.keys($dt).length <= $cv->[1]");
         }
     } elsif ($which eq 'has') {
         $c->add_ccl(
             $cd,
             "!Object.keys($dt).every(function(x){return $STR(($dt)[x]) != $STR($ct) })");
     } elsif ($which eq 'each_index') {
         $self_th->gen_each($cd, "Object.keys($dt)", '_sahv_idx', '_sahv_idx');
     } elsif ($which eq 'each_elem') {
         $self_th->gen_each($cd, "Object.keys($dt)", '_sahv_idx', "$dt\[_sahv_idx]");
     } elsif ($which eq 'check_each_index') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'check_each_elem') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'uniq') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'exists') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     }
 }
 
 sub _clause_keys_or_re_keys {
     my ($self_th, $which, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $dt = $cd->{data_term};
 
     local $cd->{_subdata_level} = $cd->{_subdata_level} + 1;
     my $use_dpath = $cd->{args}{return_type} ne 'bool';
 
 
     my $jccl;
     {
         local $cd->{ccls} = [];
 
         my $chk_x_unknown;
         my $filt_x_unknown;
         if ($which eq 'keys') {
             my $lit_valid_keys = $c->literal([keys %$cv]);
             $chk_x_unknown  = "$lit_valid_keys.indexOf(x) > -1";
             $filt_x_unknown = "$lit_valid_keys.indexOf(x) == -1";
         } else {
             my $lit_regexes = "[".
                 join(",", map { $c->_str2reliteral($cd, $_) }
                          keys %$cv)."]";
             $chk_x_unknown  = "!$lit_regexes.every(function(y) { return !x.match(y) })";
             $filt_x_unknown = "$lit_regexes.every(function(y) { return !x.match(y) })";
         }
 
         if ($cd->{clset}{"$which.restrict"} // 1) {
             local $cd->{_debug_ccl_note} = "$which.restrict";
             $c->add_ccl(
                 $cd,
                 "Object.keys($dt).every(function(x){ return $chk_x_unknown })",
                 {
                     err_msg => 'TMP1',
                     err_expr => join(
                         "",
                         $c->literal($c->_xlt(
                             $cd, "hash contains ".
                                 "unknown field(s) (%s)")),
                         '.replace("%s", ',
                         "Object.keys($dt).filter(function(x){ return $filt_x_unknown }).join(', ')",
                         ')',
                     ),
                 },
             );
         }
         delete $cd->{uclset}{"$which.restrict"};
 
         my $cdef;
         if ($which eq 'keys') {
             $cdef = $cd->{clset}{"keys.create_default"} // 1;
             delete $cd->{uclset}{"keys.create_default"};
         }
 
         my $nkeys = scalar(keys %$cv);
         my $i = 0;
         for my $k (sort keys %$cv) {
             my $kre = $c->_str2reliteral($cd, $k);
             local $cd->{spath} = [@{ $cd->{spath} }, $k];
             ++$i;
             my $sch = $c->main->normalize_schema($cv->{$k});
             my $kdn = $k; $kdn =~ s/\W+/_/g;
             my $klit = $which eq 're_keys' ? 'x' : $c->literal($k);
             my $kdt = "$dt\[$klit]";
             my %iargs = %{$cd->{args}};
             $iargs{outer_cd}             = $cd;
             $iargs{data_name}            = $kdn;
             $iargs{data_term}            = $kdt;
             $iargs{schema}               = $sch;
             $iargs{schema_is_normalized} = 1;
             $iargs{indent_level}++;
             my $icd = $c->compile(%iargs);
 
             my $sdef = $cdef && defined($sch->[1]{default});
 
             $c->add_var($cd, '_sahv_stack', []) if $use_dpath;
 
             my @code = (
                 ($c->indent_str($cd), "(_sahv_dpath.push(null), _sahv_stack.push(null), _sahv_stack[_sahv_stack.length-1] = \n")
                     x !!($use_dpath && $i == 1),
 
                 ("Object.keys($dt).every(function(x) { return (")
                     x !!($which eq 're_keys'),
 
                 $which eq 're_keys' ? "!x.match($kre) || (" :
                     ($sdef ? "" : "!$dt.hasOwnProperty($klit) || ("),
 
                 ($c->indent_str($cd), "(_sahv_dpath[_sahv_dpath.length-1] = ".
                      ($which eq 're_keys' ? 'x' : $klit)."),\n") x !!$use_dpath,
                 $icd->{result}, "\n",
 
                 $which eq 're_keys' || !$sdef ? ")" : "",
 
                 (") })")
                     x !!($which eq 're_keys'),
 
                 ($c->indent_str($cd), "), _sahv_dpath.pop(), _sahv_stack.pop()\n")
                     x !!($use_dpath && $i == $nkeys),
             );
             my $ires = join("", @code);
             local $cd->{_debug_ccl_note} = "$which: ".$c->literal($k);
             $c->add_ccl($cd, $ires);
         }
         $jccl = $c->join_ccls(
             $cd, $cd->{ccls}, {err_msg => ''});
     }
     $c->add_ccl($cd, $jccl, {});
 }
 
 sub clause_keys {
     my ($self, $cd) = @_;
     $self->_clause_keys_or_re_keys('keys', $cd);
 }
 
 sub clause_re_keys {
     my ($self, $cd) = @_;
     $self->_clause_keys_or_re_keys('re_keys', $cd);
 }
 
 sub clause_req_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl(
       $cd,
       "($ct).every(function(x){ return Object.keys($dt).indexOf(x) > -1 })", 
       {
         err_msg => 'TMP',
         err_expr => join(
             "",
             $c->literal($c->_xlt(
                 $cd, "hash has missing required field(s) (%s)")),
             '.replace("%s", ',
             "($ct).filter(function(x){ return Object.keys($dt).indexOf(x) == -1 }).join(', ')",
             ')',
         ),
       }
     );
 }
 
 sub clause_allowed_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl(
       $cd,
       "Object.keys($dt).every(function(x){ return ($ct).indexOf(x) > -1 })", 
       {
         err_msg => 'TMP',
         err_expr => join(
             "",
             $c->literal($c->_xlt(
                 $cd, "hash contains non-allowed field(s) (%s)")),
             '.replace("%s", ',
             "Object.keys($dt).filter(function(x){ return ($ct).indexOf(x) == -1 }).join(', ')",
             ')',
         ),
       }
     );
 }
 
 sub clause_allowed_keys_re {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->_die_unimplemented_clause($cd, "with expr");
     }
 
     my $re = $c->_str2reliteral($cd, $cv);
     $c->add_ccl(
       $cd,
       "Object.keys($dt).every(function(x){ return x.match(RegExp($re)) })",
       {
         err_msg => 'TMP',
         err_expr => join(
             "",
             $c->literal($c->_xlt(
                 $cd, "hash contains non-allowed field(s) (%s)")),
             '.replace("%s", ',
             "Object.keys($dt).filter(function(x){ return !x.match(RegExp($re)) }).join(', ')",
             ')',
         ),
       }
     );
 }
 
 sub clause_forbidden_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl(
       $cd,
       "Object.keys($dt).every(function(x){ return ($ct).indexOf(x) == -1 })", 
       {
         err_msg => 'TMP',
         err_expr => join(
             "",
             $c->literal($c->_xlt(
                 $cd, "hash contains forbidden field(s) (%s)")),
             '.replace("%s", ',
             "Object.keys($dt).filter(function(x){ return ($ct).indexOf(x) > -1 }).join(', ')",
             ')',
         ),
       }
     );
 }
 
 sub clause_forbidden_keys_re {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->_die_unimplemented_clause($cd, "with expr");
     }
 
     my $re = $c->_str2reliteral($cd, $cv);
     $c->add_ccl(
       $cd,
       "Object.keys($dt).every(function(x){ return !x.match(RegExp($re)) })",
       {
         err_msg => 'TMP',
         err_expr => join(
             "",
             $c->literal($c->_xlt(
                 $cd, "hash contains forbidden field(s) (%s)")),
             '.replace("%s", ',
             "Object.keys($dt).filter(function(x){ return x.match(RegExp($re)) }).join(', ')",
             ')',
         ),
       }
     );
 }
 
 sub clause_choose_one_key {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl(
         $cd,
         join(
             "",
             "($ct).map(function(x) {",
             "  return ($dt).hasOwnProperty(x) ? 1:0",
             "}).reduce(function(a,b){ return a+b }) <= 1",
         ),
         {},
     );
 }
 
 sub clause_choose_all_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl(
         $cd,
         join(
             "",
             "[0, ($ct).length].indexOf(",
             "  ($ct).map(function(x) {",
             "    return ($dt).hasOwnProperty(x) ? 1:0",
             "  }).reduce(function(a,b){ return a+b })",
             ") >= 0",
         ),
         {},
     );
 }
 
 sub clause_req_one_key {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl(
         $cd,
         join(
             "",
             "($ct).map(function(x) {",
             "  return ($dt).hasOwnProperty(x) ? 1:0",
             "}).reduce(function(a,b){ return a+b }) == 1",
         ),
         {},
     );
 }
 
 sub clause_dep_any {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl(
         $cd,
         join(
             "",
             "(function(_sahv_ct, _sahv_has_prereq, _sahv_has_dep) {", 
             "  _sahv_ct = $ct; ",
             "  _sahv_has_prereq = (_sahv_ct[1]).map(function(x) {",
             "    return ($dt).hasOwnProperty(x) ? 1:0",
             "  }).reduce(function(a,b){ return a+b }) > 0; ",
             "  _sahv_has_dep    = (_sahv_ct[0].constructor===Array ? _sahv_ct[0] : [_sahv_ct[0]]).map(function(x) {",
             "    return ($dt).hasOwnProperty(x) ? 1:0",
             "  }).reduce(function(a,b){ return a+b }) > 0; ",
             "  return !_sahv_has_dep || _sahv_has_prereq",
             "})()",
         ),
         {},
     );
 }
 
 sub clause_dep_all {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl(
         $cd,
         join(
             "",
             "(function(_sahv_ct, _sahv_has_prereq, _sahv_has_dep) {", 
             "  _sahv_ct = $ct; ",
             "  _sahv_has_prereq = (_sahv_ct[1]).map(function(x) {",
             "    return ($dt).hasOwnProperty(x) ? 1:0",
             "  }).reduce(function(a,b){ return a+b }) == _sahv_ct[1].length; ",
             "  _sahv_has_dep    = (_sahv_ct[0].constructor===Array ? _sahv_ct[0] : [_sahv_ct[0]]).map(function(x) {",
             "    return ($dt).hasOwnProperty(x) ? 1:0",
             "  }).reduce(function(a,b){ return a+b }) > 0; ",
             "  return !_sahv_has_dep || _sahv_has_prereq",
             "})()",
         ),
         {},
     );
 }
 
 sub clause_req_dep_any {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl(
         $cd,
         join(
             "",
             "(function(_sahv_ct, _sahv_has_prereq, _sahv_has_dep) {", 
             "  _sahv_ct = $ct; ",
             "  _sahv_has_prereq = (_sahv_ct[1]).map(function(x) {",
             "    return ($dt).hasOwnProperty(x) ? 1:0",
             "  }).reduce(function(a,b){ return a+b }) > 0; ",
             "  _sahv_has_dep    = (_sahv_ct[0].constructor===Array ? _sahv_ct[0] : [_sahv_ct[0]]).map(function(x) {",
             "    return ($dt).hasOwnProperty(x) ? 1:0",
             "  }).reduce(function(a,b){ return a+b }) > 0; ",
             "  return _sahv_has_dep || !_sahv_has_prereq",
             "})()",
         ),
         {},
     );
 }
 
 sub clause_req_dep_all {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl(
         $cd,
         join(
             "",
             "(function(_sahv_ct, _sahv_has_prereq, _sahv_has_dep) {", 
             "  _sahv_ct = $ct; ",
             "  _sahv_has_prereq = (_sahv_ct[1]).map(function(x) {",
             "    return ($dt).hasOwnProperty(x) ? 1:0",
             "  }).reduce(function(a,b){ return a+b }) == _sahv_ct[1].length; ",
             "  _sahv_has_dep    = (_sahv_ct[0].constructor===Array ? _sahv_ct[0] : [_sahv_ct[0]]).map(function(x) {",
             "    return ($dt).hasOwnProperty(x) ? 1:0",
             "  }).reduce(function(a,b){ return a+b }) > 0; ",
             "  return _sahv_has_dep || !_sahv_has_prereq",
             "})()",
         ),
         {},
     );
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/int.pm ###
 package Data::Sah::Compiler::js::TH::int;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH::num';
 with 'Data::Sah::Type::int';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $cd->{_ccl_check_type} = "(typeof($dt)=='number' && Math.round($dt)==$dt || parseInt($dt)==$dt)";
 }
 
 sub clause_div_by {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl($cd, "$dt % $ct == 0");
 }
 
 sub clause_mod {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl($cd, "$dt % $ct\[0] == $ct\[1]");
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/num.pm ###
 package Data::Sah::Compiler::js::TH::num;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH';
 with 'Data::Sah::Type::num';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $cd->{_ccl_check_type} = "(typeof($dt)=='number' || parseFloat($dt)==$dt)";
 }
 
 sub before_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
 
     $self->set_tmp_data_term(
         $cd, "typeof($dt)=='number' ? $dt : parseFloat($dt)");
 }
 
 sub after_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $self->restore_data_term($cd);
 }
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "$dt == $ct");
     } elsif ($which eq 'in') {
         $c->add_ccl($cd, "($ct).indexOf($dt) > -1");
     }
 }
 
 sub superclause_sortable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'min') {
         $c->add_ccl($cd, "$dt >= $ct");
     } elsif ($which eq 'xmin') {
         $c->add_ccl($cd, "$dt > $ct");
     } elsif ($which eq 'max') {
         $c->add_ccl($cd, "$dt <= $ct");
     } elsif ($which eq 'xmax') {
         $c->add_ccl($cd, "$dt < $ct");
     } elsif ($which eq 'between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt >= $ct\[0] && $dt <= $ct\[1]");
         } else {
             $c->add_ccl($cd, "$dt >= $cv->[0] && $dt <= $cv->[1]");
         }
     } elsif ($which eq 'xbetween') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt > $ct\[0] && $dt < $ct\[1]");
         } else {
             $c->add_ccl($cd, "$dt > $cv->[0] && $dt < $cv->[1]");
         }
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/obj.pm ###
 package Data::Sah::Compiler::js::TH::obj;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH';
 with 'Data::Sah::Type::obj';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $cd->{_ccl_check_type} = "typeof($dt) == 'object'";
 }
 
 sub clause_can {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl($cd, "typeof($dt\[$ct])=='function'");
 }
 
 sub clause_isa {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->_die_unimplemented_clause($cd);
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/re.pm ###
 package Data::Sah::Compiler::js::TH::re;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH';
 with 'Data::Sah::Type::re';
 
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "$dt instanceof RegExp";
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/str.pm ###
 package Data::Sah::Compiler::js::TH::str;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH';
 with 'Data::Sah::Type::str';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "typeof($dt)=='string' || typeof($dt)=='number'";
 }
 
 sub before_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
 
     $self->set_tmp_data_term($cd, "typeof($dt)=='number' ? ''+$dt : $dt");
 }
 
 sub after_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $self->restore_data_term($cd);
 }
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "$dt == $ct");
     } elsif ($which eq 'in') {
         $c->add_ccl($cd, "($ct).indexOf($dt) > -1");
     }
 }
 
 sub superclause_sortable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'min') {
         $c->add_ccl($cd, "$dt >= $ct");
     } elsif ($which eq 'xmin') {
         $c->add_ccl($cd, "$dt > $ct");
     } elsif ($which eq 'max') {
         $c->add_ccl($cd, "$dt <= $ct");
     } elsif ($which eq 'xmax') {
         $c->add_ccl($cd, "$dt < $ct");
     } elsif ($which eq 'between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt >= ($ct)[0] && $dt <= ($ct)[1]");
         } else {
             $c->add_ccl($cd, "$dt >= ".$c->literal($cv->[0]).
                             " && $dt <= ".$c->literal($cv->[1]));
         }
     } elsif ($which eq 'xbetween') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt > ($ct)[0] && $dt < ($ct)[1]");
         } else {
             $c->add_ccl($cd, "$dt > ".$c->literal($cv->[0]).
                             " && $dt < ".$c->literal($cv->[1]));
         }
     }
 }
 
 sub superclause_has_elems {
     my ($self_th, $which, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'len') {
         $c->add_ccl($cd, "($dt).length == $ct");
     } elsif ($which eq 'min_len') {
         $c->add_ccl($cd, "($dt).length >= $ct");
     } elsif ($which eq 'max_len') {
         $c->add_ccl($cd, "($dt).length <= $ct");
     } elsif ($which eq 'len_between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl(
                 $cd, "($dt).length >= ($ct)[0] && ".
                     "($dt).length >= ($ct)[1]");
         } else {
             $c->add_ccl(
                 $cd, "($dt).length >= $cv->[0] && ".
                     "($dt).length <= $cv->[1]");
         }
     } elsif ($which eq 'has') {
         $c->add_ccl($cd, "($dt).indexOf($ct) > -1");
     } elsif ($which eq 'each_index') {
         $self_th->gen_each($cd, $c->expr_array_0_nmin1("($dt).length"), '_sahv_idx', '_sahv_idx');
     } elsif ($which eq 'each_elem') {
         $self_th->gen_each($cd, $c->expr_array_0_nmin1("($dt).length"), '_sahv_idx', "$dt.charAt(_sahv_idx)");
     } elsif ($which eq 'check_each_index') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'check_each_elem') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'uniq') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'exists') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     }
 }
 
 sub clause_encoding {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->_die($cd, "Only 'utf8' encoding is currently supported")
         unless $cv eq 'utf8';
 }
 
 sub clause_match {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     my $re;
     if ($cd->{cl_is_expr}) {
         $re = $ct;
     } else {
         $re = $c->_str2reliteral($cd, $cv);
     }
 
     $c->add_ccl($cd, join(
         "",
         "(function(){ ",
         "var _sahv_match = true; ",
         "try { _sahv_match = ($dt).match(RegExp($re)) } catch(e) { if (e.name=='SyntaxError') _sahv_match = false } ",
         ($cd->{cl_is_expr} ?
              "return _sahv_match == !!($ct);" :
                  "return ".($cv ? '':'!')."!!_sahv_match;"),
         "} )()",
     ));
 }
 
 sub clause_is_re {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl($cd, join(
         "",
         "(function(){ var _sahv_is_re = true; ",
         "try { RegExp($dt) } catch(e) { if (e.name=='SyntaxError') _sahv_is_re = false } ",
         ($cd->{cl_is_expr} ?
             "return _sahv_is_re == !!($ct);" :
                 "return ".($cv ? '':'!')."_sahv_is_re;"),
         "} )()",
     ));
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/js/TH/undef.pm ###
 package Data::Sah::Compiler::js::TH::undef;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::js::TH';
 with 'Data::Sah::Type::undef';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "$dt === undefined || $dt === null";
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl.pm ###
 package Data::Sah::Compiler::perl;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Data::Dmp qw(dmp);
 use Mo qw(build default);
 use String::Indent ();
 
 extends 'Data::Sah::Compiler::Prog';
 
 our $PP;
 our $CORE;
 our $CORE_OR_PP;
 our $NO_MODULES;
 
 sub BUILD {
     my ($self, $args) = @_;
 
     $self->comment_style('shell');
     $self->indent_character(" " x 4);
     $self->var_sigil('$');
     $self->concat_op(".");
 }
 
 sub name { "perl" }
 
 sub literal {
     dmp($_[1]);
 }
 
 sub expr {
     my ($self, $expr) = @_;
     $self->expr_compiler->perl($expr);
 }
 
 sub compile {
     my ($self, %args) = @_;
 
 
 
     $args{pp} //= $PP // $ENV{DATA_SAH_PP} // 0;
     $args{core} //= $CORE // $ENV{DATA_SAH_CORE} // 0;
     $args{core_or_pp} //= $CORE_OR_PP // $ENV{DATA_SAH_CORE_OR_PP} // 0;
     $args{no_modules} //= $NO_MODULES // $ENV{DATA_SAH_NO_MODULES} // 0;
 
     $self->SUPER::compile(%args);
 }
 
 sub init_cd {
     my ($self, %args) = @_;
 
     my $cd = $self->SUPER::init_cd(%args);
 
     if (my $ocd = $cd->{outer_cd}) {
         $cd->{module_statements} = $ocd->{module_statements};
     } else {
         $cd->{module_statements} = {};
     }
 
     $self->add_no($cd, 'warnings', ["'void'"]) unless $cd->{args}{no_modules};
 
     $cd;
 }
 
 sub true { "1" }
 
 sub false { "''" }
 
 sub add_module {
     my ($self, $cd, $name) = @_;
     $self->SUPER::add_module($cd, $name);
 
     if ($cd->{args}{no_modules}) {
         die "BUG: Use of module '$name' when compile option no_modules=1";
     }
 
     if ($cd->{args}{pp}) {
         if ($name =~ /\A(DateTime|List::Util|Scalar::Util|Scalar::Util::Numeric|Storable|Time::Moment|Time::Piece)\z/) {
             die "Use of XS module '$name' when compile option pp=1";
         } elsif ($name =~ /\A(experimental|warnings|DateTime::Duration|Scalar::Util::Numeric::PP)\z/) {
         } else {
             die "BUG: Haven't noted about Perl module '$name' as being pp/xs";
         }
     }
 
     if ($cd->{args}{core}) {
         if ($name =~ /\A(experimental|DateTime|DateTime::Duration|Scalar::Util::Numeric|Scalar::Util::Numeric::PP|Time::Moment)\z/) {
             die "Use of non-core module '$name' when compile option core=1";
         } elsif ($name =~ /\A(warnings|List::Util|Scalar::Util|Storable|Time::Piece)\z/) {
         } else {
             die "BUG: Haven't noted about Perl module '$name' as being core/non-core";
         }
     }
 
     if ($cd->{args}{core_or_pp}) {
         if ($name =~ /\A(DateTime|Scalar::Util::Numeric|Time::Moment)\z/) {
             die "Use of non-core XS module '$name' when compile option core_or_pp=1";
         } elsif ($name =~ /\A(experimental|warnings|DateTime::Duration|List::Util|Scalar::Util|Scalar::Util::Numeric::PP|Storable|Time::Piece)\z/) {
         } else {
             die "BUG: Haven't noted about Perl module '$name' as being core_or_pp/not";
         }
     }
 }
 
 sub add_use {
     my ($self, $cd, $name, $imports) = @_;
 
     die "BUG: imports must be an arrayref"
         if defined($imports) && ref($imports) ne 'ARRAY';
     $self->add_module($cd, $name);
     $cd->{module_statements}{$name} = ['use', $imports];
 }
 
 sub add_no {
     my ($self, $cd, $name, $imports) = @_;
 
     die "BUG: imports must be an arrayref"
         if defined($imports) && ref($imports) ne 'ARRAY';
     $self->add_module($cd, $name);
     $cd->{module_statements}{$name} = ['no', $imports];
 }
 
 sub add_smartmatch_pragma {
     my ($self, $cd) = @_;
     $self->add_use($cd, 'experimental', ["'smartmatch'"]);
 }
 
 sub add_sun_module {
     my ($self, $cd) = @_;
     if ($cd->{args}{pp} || $cd->{args}{core_or_pp} ||
             !eval { require Scalar::Util::Numeric; 1 }) {
         $cd->{_sun_module} = 'Scalar::Util::Numeric::PP';
     } elsif ($cd->{args}{core}) {
         $cd->{_sun_module} = 'Foo';
     } else {
         $cd->{_sun_module} = 'Scalar::Util::Numeric';
     }
     $self->add_module($cd, $cd->{_sun_module});
 }
 
 sub expr_defined {
     my ($self, $t) = @_;
     "defined($t)";
 }
 
 sub expr_array_subscript {
     my ($self, $at, $idxt) = @_;
     "$at->\[$idxt]";
 }
 
 sub expr_last_elem {
     my ($self, $at, $idxt) = @_;
     "$at->\[-1]";
 }
 
 sub expr_push {
     my ($self, $at, $elt) = @_;
     "push(\@{$at}, $elt)";
 }
 
 sub expr_pop {
     my ($self, $at, $elt) = @_;
     "pop(\@{$at})";
 }
 
 sub expr_push_and_pop_dpath_between_expr {
     my ($self, $et) = @_;
     join(
         "",
         "[",
         $self->expr_push('$_sahv_dpath', $self->literal(undef)), ", ", 
         "~~", $self->enclose_paren($et), ", ", 
         $self->expr_pop('$_sahv_dpath'), 
         "]->[1]",
     );
 }
 
 sub expr_prefix_dpath {
     my ($self, $t) = @_;
     '(@$_sahv_dpath ? \'@\'.join("/",@$_sahv_dpath).": " : "") . ' . $t;
 }
 
 sub expr_setif {
     my ($self, $l, $r) = @_;
     "($l //= $r)";
 }
 
 sub expr_set_err_str {
     my ($self, $et, $err_expr) = @_;
     "($et //= $err_expr)";
 }
 
 sub expr_set_err_full {
     my ($self, $et, $k, $err_expr) = @_;
     "($et\->{$k}{join('/',\@\$_sahv_dpath)} //= $err_expr)";
 }
 
 sub expr_reset_err_str {
     my ($self, $et, $err_expr) = @_;
     "($et = undef, 1)";
 }
 
 sub expr_reset_err_full {
     my ($self, $et) = @_;
     "(delete($et\->{errors}{join('/',\@\$_sahv_dpath)}), 1)";
 }
 
 sub expr_log {
     my ($self, $cd, @expr) = @_;
 
     "\$log->tracef('[sah validator](spath=%s) %s', " .
         $self->literal($cd->{spath}).", " . join(", ", @expr) . ")";
 }
 
 sub expr_block {
     my ($self, $code) = @_;
     join(
         "",
         "do {\n",
         String::Indent::indent(
             $self->indent_character,
             $code,
         ),
         "}",
     );
 }
 
 sub block_uses_sub { 0 }
 
 sub stmt_declare_local_var {
     my ($self, $v, $vt) = @_;
     if ($vt eq 'undef') {
         "my \$$v;";
     } else {
         "my \$$v = $vt;";
     }
 }
 
 sub expr_anon_sub {
     my ($self, $args, $code) = @_;
     join(
         "",
         "sub {\n",
         String::Indent::indent(
             $self->indent_character,
             join(
                 "",
                 ("my (".join(", ", @$args).") = \@_;\n") x !!@$args,
                 $code,
             ),
         ),
         "}"
     );
 }
 
 sub stmt_require_module {
     my ($self, $mod, $cd) = @_;
     my $ms = $cd->{module_statements};
 
     if (!$ms->{$mod}) {
         "require $mod;";
     } elsif ($ms->{$mod}[0] eq 'use' || $ms->{$mod}[0] eq 'no') {
         my $verb = $ms->{$mod}[0];
         if (!$ms->{$mod}[1]) {
             "$verb $mod;";
         } else {
             "$verb $mod (".join(", ", @{ $ms->{$mod}[1] }).");";
         }
     }
 }
 
 sub stmt_require_log_module {
     my ($self, $mod) = @_;
     'use Log::Any qw($log);';
 }
 
 sub stmt_return {
     my $self = shift;
     if (@_) {
         "return($_[0]);";
     } else {
         'return;';
     }
 }
 
 sub expr_validator_sub {
     my ($self, %args) = @_;
 
     $self->check_compile_args(\%args);
 
     my $aref = delete $args{accept_ref};
     if ($aref) {
         $args{var_term}  = '$ref_'.$args{data_name};
         $args{data_term} = '$$ref_'.$args{data_name};
     } else {
         $args{var_term}  = '$'.$args{data_name};
         $args{data_term} = '$'.$args{data_name};
     }
 
     $self->SUPER::expr_validator_sub(%args);
 }
 
 sub _str2reliteral {
     require Regexp::Stringify;
 
     my ($self, $cd, $str) = @_;
 
     my $re;
     if (ref($str) eq 'Regexp') {
         $re = $str;
     } else {
         eval { $re = qr/$str/ };
         $self->_die($cd, "Invalid regex $str: $@") if $@;
     }
 
     Regexp::Stringify::stringify_regexp(regexp=>$re, plver=>5.010);
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH.pm ###
 package Data::Sah::Compiler::perl::TH;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::Prog::TH';
 
 sub gen_each {
     my ($self, $cd, $indices_expr, $data_name, $data_term, $code_at_sub_begin) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $dt = $cd->{data_term};
 
     local $cd->{_subdata_level} = $cd->{_subdata_level} + 1;
     my $use_dpath = $cd->{args}{return_type} ne 'bool';
 
     $c->add_module($cd, 'List::Util');
     my %iargs = %{$cd->{args}};
     $iargs{outer_cd}             = $cd;
     $iargs{data_name}            = $data_name;
     $iargs{data_term}            = $data_term;
     $iargs{schema}               = $cv;
     $iargs{schema_is_normalized} = 0;
     $iargs{indent_level}++;
     my $icd = $c->compile(%iargs);
     my @code = (
         "!defined(List::Util::first(sub {", ($code_at_sub_begin // ''), "!(\n",
         ($c->indent_str($cd),
          "(\$_sahv_dpath->[-1] = \$_),\n") x !!$use_dpath,
          $icd->{result}, "\n",
          $c->indent_str($icd), ")}, ",
          $indices_expr,
          "))",
     );
     $c->add_ccl($cd, join("", @code), {subdata=>1});
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/all.pm ###
 package Data::Sah::Compiler::perl::TH::all;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 
 use parent (
     'Data::Sah::Compiler::perl::TH',
     'Data::Sah::Compiler::Prog::TH::all',
 );
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/any.pm ###
 package Data::Sah::Compiler::perl::TH::any;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 
 use parent (
     'Data::Sah::Compiler::perl::TH',
     'Data::Sah::Compiler::Prog::TH::any',
 );
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/array.pm ###
 package Data::Sah::Compiler::perl::TH::array;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH';
 with 'Data::Sah::Type::array';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "ref($dt) eq 'ARRAY'";
 }
 
 my $FRZ = "Storable::freeze";
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_module($cd, 'Storable');
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "$FRZ($dt) eq $FRZ($ct)");
     } elsif ($which eq 'in') {
         $c->add_smartmatch_pragma($cd);
         $c->add_ccl($cd, "$FRZ($dt) ~~ [map {$FRZ(\$_)} \@{ $ct }]");
     }
 }
 
 sub superclause_has_elems {
     my ($self_th, $which, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'len') {
         $c->add_ccl($cd, "\@{$dt} == $ct");
     } elsif ($which eq 'min_len') {
         $c->add_ccl($cd, "\@{$dt} >= $ct");
     } elsif ($which eq 'max_len') {
         $c->add_ccl($cd, "\@{$dt} <= $ct");
     } elsif ($which eq 'len_between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl(
                 $cd, "\@{$dt} >= $ct\->[0] && \@{$dt} >= $ct\->[1]");
         } else {
             $c->add_ccl(
                 $cd, "\@{$dt} >= $cv->[0] && \@{$dt} <= $cv->[1]");
         }
     } elsif ($which eq 'has') {
         $c->add_smartmatch_pragma($cd);
 
         $c->add_ccl($cd, "$ct ~~ $dt");
     } elsif ($which eq 'each_index') {
         $self_th->gen_each($cd, "0..\@{$dt}-1", '_', '$_');
     } elsif ($which eq 'each_elem') {
         $self_th->gen_each($cd, "0..\@{$dt}-1", '_', "$dt\->[\$_]");
     } elsif ($which eq 'check_each_index') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'check_each_elem') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'uniq') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'exists') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     }
 }
 
 sub clause_elems {
     my ($self_th, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $dt = $cd->{data_term};
 
     local $cd->{_subdata_level} = $cd->{_subdata_level} + 1;
     my $use_dpath = $cd->{args}{return_type} ne 'bool';
 
     my $jccl;
     {
         local $cd->{ccls} = [];
 
         my $cdef = $cd->{clset}{"elems.create_default"} // 1;
         delete $cd->{uclset}{"elems.create_default"};
 
         for my $i (0..@$cv-1) {
             local $cd->{spath} = [@{$cd->{spath}}, $i];
             my $sch = $c->main->normalize_schema($cv->[$i]);
             my $edt = "$dt\->[$i]";
             my %iargs = %{$cd->{args}};
             $iargs{outer_cd}             = $cd;
             $iargs{data_name}            = "$cd->{args}{data_name}_$i";
             $iargs{data_term}            = $edt;
             $iargs{schema}               = $sch;
             $iargs{schema_is_normalized} = 1;
             $iargs{indent_level}++;
             my $icd = $c->compile(%iargs);
             my @code = (
                 ($c->indent_str($cd), "(\$_sahv_dpath->[-1] = $i),\n") x !!$use_dpath,
                 $icd->{result}, "\n",
             );
             my $ires = join("", @code);
             local $cd->{_debug_ccl_note} = "elem: $i";
             if ($cdef && defined($sch->[1]{default})) {
                 $c->add_ccl($cd, $ires);
             } else {
                 $c->add_ccl($cd, "\@{$dt} < ".($i+1)." || ($ires)");
             }
         }
         $jccl = $c->join_ccls(
             $cd, $cd->{ccls}, {err_msg => ''});
     }
     $c->add_ccl($cd, $jccl, {subdata=>1});
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/bool.pm ###
 package Data::Sah::Compiler::perl::TH::bool;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH';
 with 'Data::Sah::Type::bool';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "!ref($dt)";
 }
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "($dt ? 1:0) == ($ct ? 1:0)");
     } elsif ($which eq 'in') {
         $c->add_smartmatch_pragma($cd);
         $c->add_ccl($cd, "($dt ? 1:0) ~~ [map {\$_?1:0} \@{$ct}]");
     }
 }
 
 sub superclause_sortable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'min') {
         $c->add_ccl($cd, "($dt ? 1:0) >= ($ct ? 1:0)");
     } elsif ($which eq 'xmin') {
         $c->add_ccl($cd, "($dt ? 1:0) > ($ct ? 1:0)");
     } elsif ($which eq 'max') {
         $c->add_ccl($cd, "($dt ? 1:0) <= ($ct ? 1:0)");
     } elsif ($which eq 'xmax') {
         $c->add_ccl($cd, "($dt ? 1:0) < ($ct ? 1:0)");
     } elsif ($which eq 'between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "($dt ? 1:0) >= ($ct\->[0] ? 1:0) && ".
                             "($dt ? 1:0) <= ($ct\->[1] ? 1:0)");
         } else {
             $c->add_ccl($cd, "($dt ? 1:0) >= ($cv->[0] ? 1:0) && ".
                             "($dt ? 1:0) <= ($cv->[1] ? 1:0)");
         }
     } elsif ($which eq 'xbetween') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "($dt ? 1:0) > ($ct\->[0] ? 1:0) && ".
                             "($dt ? 1:0) < ($ct\->[1] ? 1:0)");
         } else {
             $c->add_ccl($cd, "($dt ? 1:0) > ($cv->[0] ? 1:0) && ".
                             "($dt ? 1:0) < ($cv->[1] ? 1:0)");
         }
     }
 }
 
 sub clause_is_true {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl($cd, "($ct) ? $dt : !defined($ct) ? 1 : !$dt");
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/buf.pm ###
 package Data::Sah::Compiler::perl::TH::buf;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH::str';
 with 'Data::Sah::Type::buf';
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/cistr.pm ###
 package Data::Sah::Compiler::perl::TH::cistr;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH::str';
 with 'Data::Sah::Type::cistr';
 
 sub before_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
 
     $self->set_tmp_data_term($cd, "lc($dt)");
 }
 
 sub after_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $self->restore_data_term($cd);
 }
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "$dt eq lc($ct)");
     } elsif ($which eq 'in') {
         $c->add_smartmatch_pragma($cd);
         $c->add_ccl($cd, "$dt ~~ [map {lc} \@{ $ct }]");
     }
 }
 
 sub superclause_sortable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'min') {
         $c->add_ccl($cd, "$dt ge lc($ct)");
     } elsif ($which eq 'xmin') {
         $c->add_ccl($cd, "$dt gt lc($ct)");
     } elsif ($which eq 'max') {
         $c->add_ccl($cd, "$dt le lc($ct)");
     } elsif ($which eq 'xmax') {
         $c->add_ccl($cd, "$dt lt lc($ct)");
     } elsif ($which eq 'between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt ge lc($ct\->[0]) && ".
                             "$dt le lc($ct\->[1])");
         } else {
             $c->add_ccl($cd, "$dt ge ".$c->literal(lc $cv->[0]).
                             " && $dt le ".$c->literal(lc $cv->[1]));
         }
     } elsif ($which eq 'xbetween') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt gt lc($ct\->[0]) && ".
                             "$dt lt lc($ct\->[1])");
         } else {
             $c->add_ccl($cd, "$dt gt ".$c->literal(lc $cv->[0]).
                             " && $dt lt ".$c->literal(lc $cv->[1]));
         }
     }
 }
 
 sub superclause_has_elems {
     my ($self_th, $which, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'has') {
         $c->add_ccl($cd, "index($dt, lc($ct)) > -1");
     } else {
         $self_th->SUPER::superclause_has_elems($which, $cd);
     }
 }
 
 sub __change_re_str_switch {
     my $re = shift;
 
     if ($^V ge v5.14.0) {
         state $sub = sub { my $s = shift; $s =~ /i/ ? $s : "i$s" };
         $re =~ s/\A\(\?\^(\w*):/"(?".$sub->($1).":"/e;
     } else {
         state $subl = sub { my $s = shift; $s =~ /i/ ? $s : "i$s" };
         state $subr = sub { my $s = shift; $s =~ s/i//; $s };
         $re =~ s/\A\(\?(\w*)-(\w*):/"(?".$subl->($1)."-".$subr->($2).":"/e;
     }
     return $re;
 }
 
 sub clause_match {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->add_ccl($cd, join(
             "",
             "ref($ct) eq 'Regexp' ? $dt =~ qr/$ct/i : ",
             "do { my \$re = $ct; eval { \$re = /\$re/i; 1 } && ",
             "$dt =~ \$re }",
         ));
     } else {
         my $re = $c->_str2reliteral($cd, $cv);
         $re = __change_re_str_switch($re);
         $c->add_ccl($cd, "$dt =~ /$re/i");
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/code.pm ###
 package Data::Sah::Compiler::perl::TH::code;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH';
 with 'Data::Sah::Type::code';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "ref($dt) eq 'CODE'";
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/date.pm ###
 package Data::Sah::Compiler::perl::TH::date;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 use Scalar::Util qw(blessed looks_like_number);
 
 extends 'Data::Sah::Compiler::perl::TH';
 with 'Data::Sah::Type::date';
 
 sub expr_coerce_term {
     my ($self, $cd, $t) = @_;
 
     my $c = $self->compiler;
 
     $c->add_module($cd, 'Scalar::Util');
 
     join(
         '',
         "(",
         "(Scalar::Util::blessed($t) && $t->isa('DateTime')) ? $t : ",
         "(Scalar::Util::looks_like_number($t) && $t >= 10**8 && $t <= 2**31) ? (require DateTime && DateTime->from_epoch(epoch=>$t)) : ",
         "$t =~ /\\A([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})Z\\z/ ? require DateTime && DateTime->new(year=>\$1, month=>\$2, day=>\$3, hour=>\$4, minute=>\$5, second=>\$6, time_zone=>'UTC') : ",
         "$t =~ /\\A([0-9]{4})-([0-9]{2})-([0-9]{2})\\z/ ? require DateTime && DateTime->new(year=>\$1, month=>\$2, day=>\$3, time_zone=>'UTC') : die(\"BUG: can't coerce date\")",
         ")",
     );
 }
 
 sub expr_coerce_value {
     my ($self, $cd, $v) = @_;
 
     my $c = $self->compiler;
 
     if (blessed($v) && $v->isa('DateTime')) {
         return join(
             '',
             "DateTime->new(",
             "year=>",   $v->year, ",",
             "month=>",  $v->month, ",",
             "day=>",    $v->day, ",",
             "hour=>",   $v->hour, ",",
             "minute=>", $v->minute, ",",
             "second=>", $v->second, ",",
             "timezone=>'UTC',",
             ")",
         );
     } elsif (looks_like_number($v) && $v >= 10**8 && $v <= 2**31) {
         return "require DateTime && DateTime->from_epoch(epoch=>$v)";
     } elsif ($v =~ /\A([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})Z\z/) {
         require DateTime;
         eval { DateTime->new(year=>$1, month=>$2, day=>$3,
                              hour=>$4, minute=>$5, second=>$6,
                              time_zone=>'UTC') ; 1 }
             or die "Invalid date literal '$v': $@";
         return "DateTime->new(year=>$1, month=>$2, day=>$3, hour=>$4, minute=>$5, second=>$6, time_zone=>'UTC')";
     } elsif ($v =~ /\A([0-9]{4})-([0-9]{2})-([0-9]{2})\z/) {
         require DateTime;
         eval { DateTime->new(year=>$1, month=>$2, day=>$3, time_zone=>'UTC') ; 1 }
             or die "Invalid date literal '$v': $@";
         return "DateTime->new(year=>$1, month=>$2, day=>$3, time_zone=>'UTC')";
     } else {
         die "Invalid date literal '$v'";
     }
 }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $dt = $cd->{data_term};
 
     $c->add_module($cd, 'Scalar::Util');
     $cd->{_ccl_check_type} = join(
         '',
         "(",
         "(Scalar::Util::blessed($dt) && $dt->isa('DateTime'))",
         " || ",
         "(Scalar::Util::looks_like_number($dt) && $dt >= 10**8 && $dt <= 2**31)",
         " || ",
         "($dt =~ /\\A([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})Z\\z/ && eval { require DateTime; DateTime->new(year=>\$1, month=>\$2, day=>\$3, hour=>\$4, minute=>\$5, second=>\$6, time_zone=>'UTC'); 1})",
         " || ",
         "($dt =~ /\\A([0-9]{4})-([0-9]{2})-([0-9]{2})\\z/ && eval { require DateTime; DateTime->new(year=>\$1, month=>\$2, day=>\$3, time_zone=>'UTC'); 1})",
         ")",
     );
 }
 
 sub before_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $self->set_tmp_data_term($cd, $self->expr_coerce_term($cd, $dt))
         if $cd->{has_constraint_clause}; 
 }
 
 sub after_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $self->restore_data_term($cd)
         if $cd->{has_constraint_clause};
 }
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         if ($cd->{cl_is_expr}) {
             $ct = $self->expr_coerce_term($cd, $ct);
         } else {
             $ct = $self->expr_coerce_value($cd, $cv);
         }
         $c->add_ccl($cd, "DateTime->compare($dt, $ct)==0");
     } elsif ($which eq 'in') {
         $c->add_module('List::Util');
         if ($cd->{cl_is_expr}) {
             $c->_die($cd, "date's in clause with expression not yet supported");
         } else {
             $ct = join(', ', map { $self->expr_coerce_value($cd, $_) } @$cv);
         };
         $c->add_ccl($cd, "List::Util::first(sub{DateTime->compare($dt, \$_)==0}, $ct)");
     }
 }
 
 sub superclause_sortable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->_die($cd, "date's comparison with expression not yet supported");
     }
 
     if ($which eq 'min') {
         $c->add_ccl($cd, "DateTime->compare($dt, ".
                         $self->expr_coerce_value($cd, $cv).") >= 0");
     } elsif ($which eq 'xmin') {
         $c->add_ccl($cd, "DateTime->compare($dt, ".
                         $self->expr_coerce_value($cd, $cv).") > 0");
     } elsif ($which eq 'max') {
         $c->add_ccl($cd, "DateTime->compare($dt, ".
                         $self->expr_coerce_value($cd, $cv).") <= 0");
     } elsif ($which eq 'xmax') {
         $c->add_ccl($cd, "DateTime->compare($dt, ".
                         $self->expr_coerce_value($cd, $cv).") < 0");
     } elsif ($which eq 'between') {
         $c->add_ccl($cd,
                     join(
                         '',
                         "DateTime->compare($dt, ",
                         $self->expr_coerce_value($cd, $cv->[0]).") >= 0 && ",
                         "DateTime->compare($dt, ",
                         $self->expr_coerce_value($cd, $cv->[1]).") <= 0",
                     ));
     } elsif ($which eq 'xbetween') {
         $c->add_ccl($cd,
                     join(
                         '',
                         "DateTime->compare($dt, ",
                         $self->expr_coerce_value($cd, $cv->[0]).") > 0 && ",
                         "DateTime->compare($dt, ",
                         $self->expr_coerce_value($cd, $cv->[1]).") < 0",
                     ));
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/duration.pm ###
 package Data::Sah::Compiler::perl::TH::duration;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 use Scalar::Util qw(blessed looks_like_number);
 
 extends 'Data::Sah::Compiler::perl::TH';
 with 'Data::Sah::Type::duration';
 
 sub expr_coerce_term {
     my ($self, $cd, $t) = @_;
 
     my $c = $self->compiler;
 
 
 
     $c->add_module($cd, 'Scalar::Util');
 
     join(
         '',
         "(",
         "(Scalar::Util::blessed($t) && $t->isa('DateTime::Duration')) ? $t : ",
         "(Scalar::Util::looks_like_number($t) && $t >= 0 ? $t : (require DateTime::Duration && DateTime::Duration->new(seconds=>$t))",
         "$t =~ /\\AP(?:([0-9]+(?:\\.[0-9]+)?)Y)? (?:([0-9]+(?:\\.[0-9]+)?)M)? (?:([0-9]+(?:\\.[0-9]+)?)W)? (?:([0-9]+(?:\\.[0-9]+)?)D)? (?: T (?:([0-9]+(?:\\.[0-9]+)?)H)? (?:([0-9]+(?:\\.[0-9]+)?)M)? (?:([0-9]+(?:\\.[0-9]+)?)S)? )?\\z/x ? require DateTime::Duration && DateTime::Duration->new(years=>\$1||0, months=>\$2||0, weeks=>\$3||0, days=>\$4||0, hours=>\$5||0, minutes=>\$6||0, seconds=>\$7||0) : ",
         "do { my \$d; eval { require Time::Duration::Parse::AsHash; \$d = Time::Duration::Parse::AsHash::parse_duration($t) }; \$@ ? undef : require DateTime::Duration && DateTime::Duration->new(years=>\$d->{years}//0, months=>\$d->{months}//0, weeks=>\$d->{weeks}//0, days=>\$d->{days}//0, hours=>\$d->{hours}//0, minutes=>\$d->{minutes}//0, seconds=>\$d->{seconds}//0) } : die(\"BUG: can't coerce duration\")",
         ")",
     );
 }
 
 sub expr_coerce_value {
     my ($self, $cd, $v) = @_;
 
     my $c = $self->compiler;
 
     my $d;
 
     if (blessed($v) && $v->isa('DateTime::Duration')) {
         return join(
             '',
             "DateTime::Duration->new(",
             "years=>",   $v->years,   ",",
             "months=>",  $v->months,  ",",
             "weeks=>",   $v->weeks,   ",",
             "days=>",    $v->days,    ",",
             "hours=>",   $v->hours,   ",",
             "minutes=>", $v->minutes, ",",
             "seconds=>", $v->seconds, ",",
             ")",
         );
     } if (looks_like_number($v) && $v >= 0) {
         return "require DateTime::Duration && DateTime::Duration->new(seconds=>$v)";
     } elsif ($v =~ /\AP
                     (?:([0-9]+(?:\.[0-9]+)?)Y)?
                     (?:([0-9]+(?:\.[0-9]+)?)M)?
                     (?:([0-9]+(?:\.[0-9]+)?)W)?
                     (?:([0-9]+(?:\.[0-9]+)?)D)?
                     (?: T
                         (?:([0-9]+(?:\.[0-9]+)?)H)?
                         (?:([0-9]+(?:\.[0-9]+)?)M)?
                         (?:([0-9]+(?:\.[0-9]+)?)S)?
                     )?\z/x) {
         return "require DateTime::Duration && DateTime::Duration->new(years=>".($1||0).", months=>".($2||0).", weeks=>".($3||0).", days=>".($4||0).", hours=>".($5||0).", minutes=>".($6||0).", seconds=>".($7||0).")";
     } elsif (eval { require Time::Duration::Parse::AsHash; $d = Time::Duration::Parse::AsHash::parse_duration($v) } && !$@) {
         return "require DateTime::Duration && DateTime::Duration->new(years=>".($d->{years}||0).", months=>".($d->{months}||0).", weeks=>".($d->{weeks}||0).", days=>".($d->{days}||0).", hours=>".($d->{hours}||0).", minutes=>".($d->{minutes}||0).", seconds=>".($d->{seconds}||0).")";
     } else {
         die "Invalid duration literal '$v'";
     }
 }
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $dt = $cd->{data_term};
 
     $c->add_module($cd, 'Scalar::Util');
     $cd->{_ccl_check_type} = join(
         '',
         "(",
         "(Scalar::Util::blessed($dt) && $dt->isa('DateTime::Duration'))",
         " || ",
         "(Scalar::Util::looks_like_number($dt) && $dt >= 0)",
         " || ",
         "($dt =~ /\\AP(?:([0-9]+(?:\\.[0-9]+)?)Y)? (?:([0-9]+(?:\\.[0-9]+)?)M)? (?:([0-9]+(?:\\.[0-9]+)?)W)? (?:([0-9]+(?:\\.[0-9]+)?)D)? (?: T (?:([0-9]+(?:\\.[0-9]+)?)H)? (?:([0-9]+(?:\\.[0-9]+)?)M)? (?:([0-9]+(?:\\.[0-9]+)?)S)? )?\\z/x)", 
         " || ",
         "do { my \$d; eval { require Time::Duration::Parse::AsHash; \$d = Time::Duration::Parse::AsHash::parse_duration($dt) }; !\$@ }",
         ")",
     );
 }
 
 sub before_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
 
     $self->set_tmp_data_term($cd, $self->expr_coerce_term($cd, $dt))
         if $cd->{has_constraint_clause}; 
 }
 
 sub after_all_clauses {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     $self->restore_data_term($cd)
         if $cd->{has_constraint_clause};
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/float.pm ###
 package Data::Sah::Compiler::perl::TH::float;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH::num';
 with 'Data::Sah::Type::float';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     if ($cd->{args}{core} || $cd->{args}{no_modules}) {
         $cd->{_ccl_check_type} = "$dt =~ ".'/\A(?:[+-]?(?:0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?|((?i)\s*nan\s*)|((?i)\s*[+-]?inf(inity)?)\s*)\z/';
     } else {
         $c->add_sun_module($cd);
         $cd->{_ccl_check_type} = "$cd->{_sun_module}::isnum($dt)";
     }
 }
 
 sub clause_is_nan {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         if ($cd->{args}{core} || $cd->{args}{no_modules}) {
             $c->add_ccl(
                 $cd,
                 qq[$ct ? lc($dt+0) eq "nan" : defined($ct) ? lc($dt+0) ne "nan" : 1],
             );
         } else {
             $c->add_ccl(
                 $cd,
                 join(
                     "",
                     "$ct ? $cd->{_sun_module}::isnan($dt) : ",
                     "defined($ct) ? !$cd->{_sun_module}::isnan($dt) : 1",
                 )
             );
         }
     } else {
         if ($cd->{cl_value}) {
             if ($cd->{args}{core} || $cd->{args}{no_modules}) {
                 $c->add_ccl($cd, qq[lc($dt+0) eq "nan"]);
             } else {
                 $c->add_ccl($cd, "$cd->{_sun_module}::isnan($dt)");
             }
         } elsif (defined $cd->{cl_value}) {
             if ($cd->{args}{core} || $cd->{args}{no_modules}) {
                 $c->add_ccl($cd, qq[lc($dt+0) ne "nan"]);
             } else {
                 $c->add_ccl($cd, "!$cd->{_sun_module}::isnan($dt)");
             }
         }
     }
 }
 
 sub clause_is_neg_inf {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         if ($cd->{args}{core} || $cd->{args}{no_modules}) {
             $c->add_ccl(
                 $cd, join(
                     '',
                     qq[$ct ? $dt =~ /\\A\\s*-inf(inity)?\\s*\\z/i : ],
                     qq[defined($ct) ? $dt !~ /\\A\\s*inf(inity)?\\s*\\z/i : 1]
                 ));
         } else {
             $c->add_ccl(
                 $cd, join(
                     '',
                     "$ct ? $cd->{_sun_module}::isinf($dt) && $cd->{_sun_module}::isneg($dt) : ",
                     "defined($ct) ? !($cd->{_sun_module}::isinf($dt) && $cd->{_sun_module}::isneg($dt)) : 1",
                 ));
         }
     } else {
         if ($cd->{cl_value}) {
             if ($cd->{args}{core} || $cd->{args}{no_modules}) {
                 $c->add_ccl($cd, qq[$dt =~ /\\A\\s*-inf(inity)?\\s*\\z/i]);
             } else {
                 $c->add_ccl($cd, "$cd->{_sun_module}::isinf($dt) && $cd->{_sun_module}::isneg($dt)");
             }
         } elsif (defined $cd->{cl_value}) {
             if ($cd->{args}{core} || $cd->{args}{no_modules}) {
                 $c->add_ccl($cd, qq[$dt !~ /\\A\\s*-inf(inity)?\\s*\\z/i]);
             } else {
                 $c->add_ccl($cd, "!($cd->{_sun_module}::isinf($dt) && $cd->{_sun_module}::isneg($dt))");
             }
         }
     }
 }
 
 sub clause_is_pos_inf {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         if ($cd->{args}{core} || $cd->{args}{no_modules}) {
             $c->add_ccl(
                 $cd, join(
                     '',
                     qq[$ct ? $dt =~ /\\A\\s*inf(inity)?\\s*\\z/i : ],
                     qq[defined($ct) ? $dt !~ /\\A\\s*inf(inity)?\\s*\\z/i : 1]
                 ));
         } else {
             $c->add_ccl(
                 $cd, join(
                     '',
                     "$ct ? $cd->{_sun_module}::isinf($dt) && !$cd->{_sun_module}::isneg($dt) : ",
                     "defined($ct) ? !($cd->{_sun_module}::isinf($dt) && !$cd->{_sun_module}::isneg($dt)) : 1",
                 ));
         }
     } else {
         if ($cd->{cl_value}) {
             if ($cd->{args}{core} || $cd->{args}{no_modules}) {
                 $c->add_ccl($cd, qq[$dt =~ /\\A\\s*inf(inity)?\\s*\\z/i]);
             } else {
                 $c->add_ccl($cd, "$cd->{_sun_module}::isinf($dt) && !$cd->{_sun_module}::isneg($dt)");
             }
         } elsif (defined $cd->{cl_value}) {
             if ($cd->{args}{core} || $cd->{args}{no_modules}) {
                 $c->add_ccl($cd, qq[$dt !~ /\\A\\s*inf(inity)?\\s*\\z/i]);
             } else {
                 $c->add_ccl($cd, "!($cd->{_sun_module}::isinf($dt) && !$cd->{_sun_module}::isneg($dt))");
             }
         }
     }
 }
 
 sub clause_is_inf {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         if ($cd->{args}{core} || $cd->{args}{no_modules}) {
             $c->add_ccl(
                 $cd, join(
                     '',
                     qq[$ct ? $dt =~ /\\A\\s*-?inf(inity)?\\s*\\z/i : ],
                     qq[defined($ct) ? $dt+0 !~ /\\A-?inf\\z/ : 1]
                 ));
         } else {
             $c->add_ccl($cd, "$ct ? $cd->{_sun_module}::isinf($dt) : ".
                             "defined($ct) ? $cd->{_sun_module}::isinf($dt) : 1");
         }
     } else {
         if ($cd->{cl_value}) {
             if ($cd->{args}{core} || $cd->{args}{no_modules}) {
                 $c->add_ccl($cd, qq[$dt =~ /\\A\\s*-?inf(inity)?\\s*\\z/i]);
             } else {
                 $c->add_ccl($cd, "$cd->{_sun_module}::isinf($dt)");
             }
         } elsif (defined $cd->{cl_value}) {
             if ($cd->{args}{core} || $cd->{args}{no_modules}) {
                 $c->add_ccl($cd, qq[$dt !~ /\\A\\s*-?inf(inity)?\\s*\\z/i]);
             } else {
                 $c->add_ccl($cd, "!$cd->{_sun_module}::isinf($dt)");
             }
         }
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/hash.pm ###
 package Data::Sah::Compiler::perl::TH::hash;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH';
 with 'Data::Sah::Type::hash';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "ref($dt) eq 'HASH'";
 }
 
 my $FRZ = "Storable::freeze";
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_module($cd, 'Storable');
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "$FRZ($dt) eq $FRZ($ct)");
     } elsif ($which eq 'in') {
         $c->add_smartmatch_pragma($cd);
         $c->add_ccl($cd, "$FRZ($dt) ~~ [map {$FRZ(\$_)} \@{ $ct }]");
     }
 }
 
 sub superclause_has_elems {
     my ($self_th, $which, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'len') {
         $c->add_ccl($cd, "keys(\%{$dt}) == $ct");
     } elsif ($which eq 'min_len') {
         $c->add_ccl($cd, "keys(\%{$dt}) >= $ct");
     } elsif ($which eq 'max_len') {
         $c->add_ccl($cd, "keys(\%{$dt}) <= $ct");
     } elsif ($which eq 'len_between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl(
                 $cd, "keys(\%{$dt}) >= $ct\->[0] && ".
                     "keys(\%{$dt}) >= $ct\->[1]");
         } else {
             $c->add_ccl(
                 $cd, "keys(\%{$dt}) >= $cv->[0] && ".
                     "keys(\%{$dt}) <= $cv->[1]");
         }
     } elsif ($which eq 'has') {
         $c->add_smartmatch_pragma($cd);
 
         $c->add_ccl($cd, "$ct ~~ [values \%{ $dt }]");
     } elsif ($which eq 'each_index') {
         $self_th->gen_each($cd, "sort keys(\%{$dt})", '', '$_');
     } elsif ($which eq 'each_elem') {
         $self_th->gen_each($cd, "sort keys(\%{$dt})", '_', "$dt\->{\$_}");
     } elsif ($which eq 'check_each_index') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'check_each_elem') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'uniq') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'exists') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     }
 }
 
 sub _clause_keys_or_re_keys {
     my ($self_th, $which, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $dt = $cd->{data_term};
 
     local $cd->{_subdata_level} = $cd->{_subdata_level} + 1;
     my $use_dpath = $cd->{args}{return_type} ne 'bool';
 
 
     my $jccl;
     {
         local $cd->{ccls} = [];
 
         my $lit_valid_keys;
         if ($which eq 'keys') {
             $lit_valid_keys = $c->literal([sort keys %$cv]);
         } else {
             $lit_valid_keys = "[".
                 join(",", map { "qr/".$c->_str2reliteral($cd, $_)."/" }
                          sort keys %$cv)."]";
         }
 
         if ($cd->{clset}{"$which.restrict"} // 1) {
             local $cd->{_debug_ccl_note} = "$which.restrict";
             $c->add_module($cd, "List::Util");
             $c->add_smartmatch_pragma($cd);
             $c->add_ccl(
                 $cd,
                 "!defined(List::Util::first(sub {!(\$_ ~~ $lit_valid_keys)}, ".
                     "keys %{$dt}))",
                 {
                     err_msg => 'TMP1',
                     err_expr => join(
                         "",
                         'sprintf(',
                         $c->literal($c->_xlt(
                             $cd, "hash contains ".
                                 "unknown field(s) (%s)")),
                         ',',
                         "join(', ', sort grep {!(\$_ ~~ $lit_valid_keys)} ",
                         "keys %{$dt})",
                         ')',
                     ),
                 },
             );
         }
         delete $cd->{uclset}{"$which.restrict"};
 
         my $cdef;
         if ($which eq 'keys') {
             $cdef = $cd->{clset}{"keys.create_default"} // 1;
             delete $cd->{uclset}{"keys.create_default"};
         }
 
         my $nkeys = scalar(keys %$cv);
         my $i = 0;
         for my $k (sort keys %$cv) {
             my $kre = $c->_str2reliteral($cd, $k);
             local $cd->{spath} = [@{ $cd->{spath} }, $k];
             ++$i;
             my $sch = $c->main->normalize_schema($cv->{$k});
             my $kdn = $k; $kdn =~ s/\W+/_/g;
             my $klit = $which eq 're_keys' ? '$_' : $c->literal($k);
             my $kdt = "$dt\->{$klit}";
             my %iargs = %{$cd->{args}};
             $iargs{outer_cd}             = $cd;
             $iargs{data_name}            = $kdn;
             $iargs{data_term}            = $kdt;
             $iargs{schema}               = $sch;
             $iargs{schema_is_normalized} = 1;
             $iargs{indent_level}++;
             my $icd = $c->compile(%iargs);
 
             my $sdef = $cdef && defined($sch->[1]{default});
 
             $c->add_var($cd, '_sahv_stack', []) if $use_dpath;
 
             my @code = (
                 ($c->indent_str($cd), "(push(@\$_sahv_dpath, undef), push(\@\$_sahv_stack, undef), \$_sahv_stack->[-1] = \n")
                     x !!($use_dpath && $i == 1),
 
                 ('(!defined(List::Util::first(sub {!(')
                     x !!($which eq 're_keys'),
 
                 $which eq 're_keys' ? "\$_ !~ /$kre/ || (" :
                     ($sdef ? "" : "!exists($kdt) || ("),
 
                 ($c->indent_str($cd), "(\$_sahv_dpath->[-1] = ".
                      ($which eq 're_keys' ? '$_' : $klit)."),\n")
                          x !!$use_dpath,
                 $icd->{result}, "\n",
 
                 $which eq 're_keys' || !$sdef ? ")" : "",
 
                 (")}, sort keys %{ $dt })))")
                     x !!($which eq 're_keys'),
 
                 ($c->indent_str($cd), "), pop(\@\$_sahv_dpath), pop(\@\$_sahv_stack)\n")
                     x !!($use_dpath && $i == $nkeys),
             );
             my $ires = join("", @code);
             local $cd->{_debug_ccl_note} = "$which: ".$c->literal($k);
             $c->add_ccl($cd, $ires);
         }
         $jccl = $c->join_ccls(
             $cd, $cd->{ccls}, {err_msg => ''});
     }
     $c->add_ccl($cd, $jccl, {});
 }
 
 sub clause_keys {
     my ($self, $cd) = @_;
     $self->_clause_keys_or_re_keys('keys', $cd);
 }
 
 sub clause_re_keys {
     my ($self, $cd) = @_;
     $self->_clause_keys_or_re_keys('re_keys', $cd);
 }
 
 sub clause_req_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
 
     $c->add_module($cd, "List::Util");
     $c->add_ccl(
       $cd,
       "do { my \$_sahv_h = $dt; !defined(List::Util::first(sub {!exists(\$_sahv_h\->{\$_})}, \@{ $ct })) }",
       {
         err_msg => 'TMP',
         err_expr =>
           "sprintf(".
           $c->literal($c->_xlt($cd, "hash has missing required field(s) (%s)")).
           ",join(', ', do { my \$_sahv_h = $dt; grep { !exists(\$_sahv_h\->{\$_}) } \@{ $ct } }))"
       }
     );
 }
 
 sub clause_allowed_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_module($cd, "List::Util");
     $c->add_smartmatch_pragma($cd);
     $c->add_ccl(
       $cd,
       "!defined(List::Util::first(sub {!(\$_ ~~ $ct)}, keys \%{ $dt }))",
       {
         err_msg => 'TMP',
         err_expr =>
           "sprintf(".
           $c->literal($c->_xlt($cd, "hash contains non-allowed field(s) (%s)")).
           ",join(', ', sort grep { !(\$_ ~~ $ct) } keys \%{ $dt }))"
       }
     );
 }
 
 sub clause_allowed_keys_re {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->_die_unimplemented_clause($cd, "with expr");
     }
 
     my $re = $c->_str2reliteral($cd, $cv);
     $c->add_module($cd, "List::Util");
     $c->add_smartmatch_pragma($cd);
     $c->add_ccl(
         $cd,
         "!defined(List::Util::first(sub {\$_ !~ /$re/}, keys \%{ $dt }))",
         {
           err_msg => 'TMP',
           err_expr =>
           "sprintf(".
           $c->literal($c->_xlt($cd, "hash contains non-allowed field(s) (%s)")).
           ",join(', ', sort grep { \$_ !~ /$re/ } keys \%{ $dt }))"
       }
     );
 }
 
 sub clause_forbidden_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_module($cd, "List::Util");
     $c->add_smartmatch_pragma($cd);
     $c->add_ccl(
       $cd,
       "!defined(List::Util::first(sub {\$_ ~~ $ct}, keys \%{ $dt }))",
       {
         err_msg => 'TMP',
         err_expr =>
           "sprintf(".
           $c->literal($c->_xlt($cd, "hash contains forbidden field(s) (%s)")).
           ",join(', ', sort grep { \$_ ~~ $ct } keys \%{ $dt }))"
       }
     );
 }
 
 sub clause_forbidden_keys_re {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->_die_unimplemented_clause($cd, "with expr");
     }
 
     my $re = $c->_str2reliteral($cd, $cv);
     $c->add_module($cd, "List::Util");
     $c->add_smartmatch_pragma($cd);
     $c->add_ccl(
         $cd,
         "!defined(List::Util::first(sub {\$_ =~ /$re/}, keys \%{ $dt }))",
         {
           err_msg => 'TMP',
           err_expr =>
           "sprintf(".
           $c->literal($c->_xlt($cd, "hash contains forbidden field(s) (%s)")).
           ",join(', ', sort grep { \$_ =~ /$re/ } keys \%{ $dt }))"
       }
     );
 }
 
 sub clause_choose_one_key {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
 
     $c->add_module($cd, "List::Util");
     $c->add_ccl(
       $cd,
       "do { my \$_sahv_h = $dt; List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} \@{ $ct }) <= 1 }",
       {},
     );
 }
 
 sub clause_choose_all_keys {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
 
     $c->add_module($cd, "List::Util");
     $c->add_ccl(
       $cd,
       "do { my \$_sahv_h = $dt; my \$_sahv_keys = $ct; my \$_sahv_tot = List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} \@\$_sahv_keys); \$_sahv_tot==0 || \$_sahv_tot==\@\$_sahv_keys }",
       {},
     );
 }
 
 sub clause_req_one_key {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
 
     $c->add_module($cd, "List::Util");
     $c->add_ccl(
       $cd,
       "do { my \$_sahv_h = $dt; List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} \@{ $ct }) == 1 }",
       {},
     );
 }
 
 sub clause_dep_any {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
 
     $c->add_module($cd, "List::Util");
     $c->add_ccl(
       $cd,
       "do { my \$_sahv_h = $dt; my \$_sahv_ct = $ct; ".
           "my \$_sahv_has_prereq = List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} \@{ \$_sahv_ct->[1] }) ? 1:0; ".
           "my \$_sahv_has_dep    = List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} (ref(\$_sahv_ct->[0]) eq 'ARRAY' ? \@{ \$_sahv_ct->[0] } : (\$_sahv_ct->[0]))) ? 1:0; ".
           "!\$_sahv_has_dep || \$_sahv_has_prereq }",
       {},
     );
 }
 
 sub clause_dep_all {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
 
     $c->add_module($cd, "List::Util");
     $c->add_ccl(
       $cd,
       "do { my \$_sahv_h = $dt; my \$_sahv_ct = $ct; ".
           "my \$_sahv_has_prereq = List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} \@{ \$_sahv_ct->[1] }) == \@{ \$_sahv_ct->[1] } ? 1:0; ".
           "my \$_sahv_has_dep    = List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} (ref(\$_sahv_ct->[0]) eq 'ARRAY' ? \@{ \$_sahv_ct->[0] } : (\$_sahv_ct->[0]))) ? 1:0; ".
           "!\$_sahv_has_dep || \$_sahv_has_prereq }",
       {},
     );
 }
 
 sub clause_req_dep_any {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
 
     $c->add_module($cd, "List::Util");
     $c->add_ccl(
       $cd,
       "do { my \$_sahv_h = $dt; my \$_sahv_ct = $ct; ".
           "my \$_sahv_has_prereq = List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} \@{ \$_sahv_ct->[1] }) ? 1:0; ".
           "my \$_sahv_has_dep    = List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} (ref(\$_sahv_ct->[0]) eq 'ARRAY' ? \@{ \$_sahv_ct->[0] } : (\$_sahv_ct->[0]))) ? 1:0; ".
           "\$_sahv_has_dep || !\$_sahv_has_prereq }",
       {},
     );
 }
 
 sub clause_req_dep_all {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
 
     $c->add_module($cd, "List::Util");
     $c->add_ccl(
       $cd,
       "do { my \$_sahv_h = $dt; my \$_sahv_ct = $ct; ".
           "my \$_sahv_has_prereq = List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} \@{ \$_sahv_ct->[1] }) == \@{ \$_sahv_ct->[1] } ? 1:0; ".
           "my \$_sahv_has_dep    = List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} (ref(\$_sahv_ct->[0]) eq 'ARRAY' ? \@{ \$_sahv_ct->[0] } : (\$_sahv_ct->[0]))) ? 1:0; ".
           "\$_sahv_has_dep || !\$_sahv_has_prereq }",
       {},
     );
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/int.pm ###
 package Data::Sah::Compiler::perl::TH::int;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH::num';
 with 'Data::Sah::Type::int';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     if ($cd->{args}{core} || $cd->{args}{no_modules}) {
         $cd->{_ccl_check_type} = "$dt =~ ".'/\A[+-]?(?:0|[1-9][0-9]*)\z/';
     } else {
         $c->add_sun_module($cd);
         $cd->{_ccl_check_type} =
             "$cd->{_sun_module}::isint($dt)";
     }
 }
 
 sub clause_div_by {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl($cd, "$dt % $ct == 0");
 }
 
 sub clause_mod {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl($cd, "$dt % $ct\->[0] == $ct\->[1]");
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/num.pm ###
 package Data::Sah::Compiler::perl::TH::num;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH';
 with 'Data::Sah::Type::num';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
     my $dt = $cd->{data_term};
 
     if ($cd->{args}{core} || $cd->{args}{no_modules}) {
         $cd->{_ccl_check_type} = "$dt =~ ".'/\A(?:[+-]?(?:0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?|((?i)\s*nan\s*)|((?i)\s*[+-]?inf(inity)?)\s*)\z/';
     } else {
         $c->add_sun_module($cd);
         $cd->{_ccl_check_type} = "$cd->{_sun_module}::isnum($dt)";
     }
 }
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "$dt == $ct");
     } elsif ($which eq 'in') {
         $c->add_smartmatch_pragma($cd);
         $c->add_ccl($cd, "$dt ~~ $ct");
     }
 }
 
 sub superclause_sortable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'min') {
         $c->add_ccl($cd, "$dt >= $ct");
     } elsif ($which eq 'xmin') {
         $c->add_ccl($cd, "$dt > $ct");
     } elsif ($which eq 'max') {
         $c->add_ccl($cd, "$dt <= $ct");
     } elsif ($which eq 'xmax') {
         $c->add_ccl($cd, "$dt < $ct");
     } elsif ($which eq 'between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt >= $ct\->[0] && $dt <= $ct\->[1]");
         } else {
             $c->add_ccl($cd, "$dt >= $cv->[0] && $dt <= $cv->[1]");
         }
     } elsif ($which eq 'xbetween') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt > $ct\->[0] && $dt < $ct\->[1]");
         } else {
             $c->add_ccl($cd, "$dt > $cv->[0] && $dt < $cv->[1]");
         }
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/obj.pm ###
 package Data::Sah::Compiler::perl::TH::obj;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH';
 with 'Data::Sah::Type::obj';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $c->add_module($cd, 'Scalar::Util');
     $cd->{_ccl_check_type} = "Scalar::Util::blessed($dt)";
 }
 
 sub clause_can {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl($cd, "$dt->can($ct)");
 }
 
 sub clause_isa {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->add_ccl($cd, "$dt->isa($ct)");
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/re.pm ###
 package Data::Sah::Compiler::perl::TH::re;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH';
 with 'Data::Sah::Type::re';
 
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "ref($dt) eq 'Regexp' || !ref($dt) && ".
         "eval { my \$tmp = $dt; qr/\$tmp/; 1 }";
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/str.pm ###
 package Data::Sah::Compiler::perl::TH::str;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH';
 with 'Data::Sah::Type::str';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "!ref($dt)";
 }
 
 sub superclause_comparable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'is') {
         $c->add_ccl($cd, "$dt eq $ct");
     } elsif ($which eq 'in') {
         $c->add_smartmatch_pragma($cd);
         $c->add_ccl($cd, "$dt ~~ $ct");
     }
 }
 
 sub superclause_sortable {
     my ($self, $which, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'min') {
         $c->add_ccl($cd, "$dt ge $ct");
     } elsif ($which eq 'xmin') {
         $c->add_ccl($cd, "$dt gt $ct");
     } elsif ($which eq 'max') {
         $c->add_ccl($cd, "$dt le $ct");
     } elsif ($which eq 'xmax') {
         $c->add_ccl($cd, "$dt lt $ct");
     } elsif ($which eq 'between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt ge $ct\->[0] && $dt le $ct\->[1]");
         } else {
             $c->add_ccl($cd, "$dt ge ".$c->literal($cv->[0]).
                             " && $dt le ".$c->literal($cv->[1]));
         }
     } elsif ($which eq 'xbetween') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl($cd, "$dt gt $ct\->[0] && $dt lt $ct\->[1]");
         } else {
             $c->add_ccl($cd, "$dt gt ".$c->literal($cv->[0]).
                             " && $dt lt ".$c->literal($cv->[1]));
         }
     }
 }
 
 sub superclause_has_elems {
     my ($self_th, $which, $cd) = @_;
     my $c  = $self_th->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($which eq 'len') {
         $c->add_ccl($cd, "length($dt) == $ct");
     } elsif ($which eq 'min_len') {
         $c->add_ccl($cd, "length($dt) >= $ct");
     } elsif ($which eq 'max_len') {
         $c->add_ccl($cd, "length($dt) <= $ct");
     } elsif ($which eq 'len_between') {
         if ($cd->{cl_is_expr}) {
             $c->add_ccl(
                 $cd, "length($dt) >= $ct\->[0] && ".
                     "length($dt) >= $ct\->[1]");
         } else {
             $c->add_ccl(
                 $cd, "length($dt) >= $cv->[0] && ".
                     "length($dt) <= $cv->[1]");
         }
     } elsif ($which eq 'has') {
         $c->add_ccl($cd, "index($dt, $ct) >= 0");
     } elsif ($which eq 'each_index') {
         $self_th->gen_each($cd, "0..length($dt)-1", '_', '$_');
     } elsif ($which eq 'each_elem') {
         $self_th->gen_each($cd, "0..length($dt)-1", '_', "substr($dt, \$_, 1)");
     } elsif ($which eq 'check_each_index') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'check_each_elem') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'uniq') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     } elsif ($which eq 'exists') {
         $self_th->compiler->_die_unimplemented_clause($cd);
     }
 }
 
 sub clause_encoding {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     $c->_die($cd, "Only 'utf8' encoding is currently supported")
         unless $cv eq 'utf8';
 }
 
 sub clause_match {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->add_ccl($cd, join(
             "",
             "ref($ct) eq 'Regexp' ? $dt =~ $ct : ",
             "do { my \$re = $ct; eval { \$re = /\$re/; 1 } && ",
             "$dt =~ \$re }",
         ));
     } else {
         my $re = $c->_str2reliteral($cd, $cv);
         $c->add_ccl($cd, "$dt =~ qr($re)");
     }
 }
 
 sub clause_is_re {
     my ($self, $cd) = @_;
     my $c  = $self->compiler;
     my $cv = $cd->{cl_value};
     my $ct = $cd->{cl_term};
     my $dt = $cd->{data_term};
 
     if ($cd->{cl_is_expr}) {
         $c->add_ccl($cd, join(
             "",
             "do { my \$re = $dt; ",
             "(eval { \$re = qr/\$re/; 1 } ? 1:0) == ($ct ? 1:0) }",
         ));
     } else {
         $c->add_ccl($cd, join(
             "",
             "do { my \$re = $dt; ",
             ($cv ? "" : "!"), "(eval { \$re = qr/\$re/; 1 })",
             "}",
         ));
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Compiler/perl/TH/undef.pm ###
 package Data::Sah::Compiler::perl::TH::undef;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Mo qw(build default);
 use Role::Tiny::With;
 
 extends 'Data::Sah::Compiler::perl::TH';
 with 'Data::Sah::Type::undef';
 
 sub handle_type {
     my ($self, $cd) = @_;
     my $c = $self->compiler;
 
     my $dt = $cd->{data_term};
     $cd->{_ccl_check_type} = "!defined($dt)";
 }
 
 1;
 
 __END__
 
### Data/Sah/Human.pm ###
 package Data::Sah::Human;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 our $Log_Validator_Code = $ENV{LOG_SAH_VALIDATOR_CODE} // 0;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(gen_human_msg);
 
 sub gen_human_msg {
     require Data::Sah;
 
     my ($schema, $opts) = @_;
 
     state $hc = Data::Sah->new->get_compiler("human");
 
     my %args = (schema => $schema, %{$opts // {}});
     my $opt_source = delete $args{source};
 
     $args{log_result} = 1 if $Log_Validator_Code;
 
     my $cd = $hc->compile(%args);
     $opt_source ? $cd : $cd->{result};
 }
 
 1;
 
 __END__
 
### Data/Sah/JS.pm ###
 package Data::Sah::JS;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 our $Log_Validator_Code = $ENV{LOG_SAH_VALIDATOR_CODE} // 0;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(gen_validator);
 
 sub get_nodejs_path {
     require File::Which;
 
     my $path;
     for my $name (qw/nodejs node/) {
         $path = File::Which::which($name);
         next unless $path;
 
         my $cmd = "$path -e 'console.log(1+1)'";
         my $out = `$cmd`;
         if ($out =~ /\A2\n?\z/) {
             return $path;
         } else {
         }
     }
     return undef;
 }
 
 sub gen_validator {
     require Data::Sah;
 
     my ($schema, $opts) = @_;
 
     state $jsc = Data::Sah->new->get_compiler("js");
 
     my %args = (schema => $schema, %{$opts // {}});
     my $opt_source = delete $args{source};
 
     $args{log_result} = 1 if $Log_Validator_Code;
 
     my $v_src = $jsc->expr_validator_sub(%args);
     return $v_src if $opt_source;
 
     state $nodejs_path = get_nodejs_path();
     die "Can't find node.js in PATH" unless $nodejs_path;
 
 
     sub {
         require File::Temp;
         require JSON;
 
         my $data = shift;
 
         state $json = JSON->new->allow_nonref;
 
         my $src = "var validator = $v_src;\n\n".
             "console.log(JSON.stringify(validator(".
                 $json->encode($data).")))";
 
         my ($jsh, $jsfn) = File::Temp::tempfile();
         print $jsh $src;
         close($jsh) or die "Can't write JS code to file $jsfn: $!";
 
         my $cmd = "$nodejs_path $jsfn";
         my $out = `$cmd`;
         $json->decode($out);
     };
 }
 
 1;
 
 __END__
 
### Data/Sah/Lang.pm ###
 package Data::Sah::Lang;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 our @ISA    = qw(Exporter);
 our @EXPORT = qw(add_translations);
 
 sub add_translations {
     my %args = @_;
 
 }
 
 1;
 
 __END__
 
### Data/Sah/Lang/fr_FR.pm ###
 package Data::Sah::Lang::fr_FR;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Tie::IxHash;
 
 
 our %translations;
 tie %translations, 'Tie::IxHash', (
 
 
     q[ ], 
     q[ ],
 
     q[, ],
     q[, ],
 
     q[: ],
     q[: ],
 
     q[. ],
     q[. ],
 
     q[(],
     q[(],
 
     q[)],
     q[)],
 
 
     q[must],
     q[doit],
 
     q[must not],
     q[ne doit pas],
 
     q[should],
     q[devrait],
 
     q[should not],
     q[ne devrait pas],
 
 
     q[field],
     q[champ],
 
     q[fields],
     q[champs],
 
     q[argument],
     q[argument],
 
     q[arguments],
     q[arguments],
 
 
     q[%s and %s],
     q[%s et %s],
 
     q[%s or %s],
     q[%s ou %s],
 
     q[one of %s],
     q[une des %s],
 
     q[all of %s],
     q[toutes les valeurs %s],
 
     q[%(modal_verb)s satisfy all of the following],
     q[%(modal_verb)s satisfaire à toutes les conditions suivantes],
 
     q[%(modal_verb)s satisfy one of the following],
     q[%(modal_verb)s satisfaire l'une des conditions suivantes],
 
     q[%(modal_verb)s satisfy none of the following],
     q[%(modal_verb)s satisfaire à aucune des conditions suivantes],
 
 
 
 
 
 
 
     q[integer],
     q[nombre entier],
 
     q[integers],
     q[nombres entiers],
 
     q[%(modal_verb)s be divisible by %s],
     q[%(modal_verb)s être divisible par %s],
 
     q[%(modal_verb)s leave a remainder of %2$s when divided by %1$s],
     q[%(modal_verb)s laisser un reste %2$s si divisé par %1$s],
 
 );
 
 1;
 
 __END__
 
### Data/Sah/Lang/id_ID.pm ###
 package Data::Sah::Lang::id_ID;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Tie::IxHash;
 
 sub ordinate {
     my ($n, $noun) = @_;
     "$noun ke-$n";
 }
 
 our %translations;
 tie %translations, 'Tie::IxHash', (
 
 
     q[ ], 
     q[ ],
 
     q[, ],
     q[, ],
 
     q[: ],
     q[: ],
 
     q[. ],
     q[. ],
 
     q[(],
     q[(],
 
     q[)],
     q[)],
 
 
     q[must],
     q[harus],
 
     q[must not],
     q[tidak boleh],
 
     q[should],
     q[sebaiknya],
 
     q[should not],
     q[sebaiknya tidak],
 
 
     q[field],
     q[field],
 
     q[fields],
     q[field],
 
     q[argument],
     q[argumen],
 
     q[arguments],
     q[argumen],
 
 
     q[%s and %s],
     q[%s dan %s],
 
     q[%s or %s],
     q[%s atau %s],
 
     q[%s nor %s],
     q[%s maupun %s],
 
     q[one of %s],
     q[salah satu dari %s],
 
     q[all of %s],
     q[semua dari nilai-nilai %s],
 
     q[any of %s],
     q[satupun dari %s],
 
     q[none of %s],
     q[tak satupun dari %s],
 
     q[%(modal_verb)s satisfy all of the following],
     q[%(modal_verb)s memenuhi semua ketentuan ini],
 
     q[%(modal_verb)s satisfy none all of the following],
     q[%(modal_verb)s melanggar semua ketentuan ini],
 
     q[%(modal_verb)s satisfy one of the following],
     q[%(modal_verb)s memenuhi salah satu ketentuan ini],
 
 
     q[default value is %s],
     q[jika tidak diisi diset ke %s],
 
     q[required %s],
     q[%s wajib diisi],
 
     q[optional %s],
     q[%s opsional],
 
     q[forbidden %s],
     q[%s tidak boleh diisi],
 
 
     q[%(modal_verb)s have the value %s],
     q[%(modal_verb)s bernilai %s],
 
     q[%(modal_verb)s be one of %s],
     q[%(modal_verb)s salah satu dari %s],
 
 
     q[length %(modal_verb)s be %s],
     q[panjang %(modal_verb)s %s],
 
     q[length %(modal_verb)s be at least %s],
     q[panjang %(modal_verb)s minimal %s],
 
     q[length %(modal_verb)s be at most %s],
     q[panjang %(modal_verb)s maksimal %s],
 
     q[length %(modal_verb)s be between %s and %s],
     q[panjang %(modal_verb)s antara %s dan %s],
 
     q[%(modal_verb)s have %s in its elements],
     q[%(modal_verb)s mengandung %s di elemennya],
 
 
     q[%(modal_verb)s be at least %s],
     q[%(modal_verb)s minimal %s],
 
     q[%(modal_verb)s be larger than %s],
     q[%(modal_verb)s lebih besar dari %s],
 
     q[%(modal_verb)s be at most %s],
     q[%(modal_verb)s maksimal %s],
 
     q[%(modal_verb)s be smaller than %s],
     q[%(modal_verb)s lebih kecil dari %s],
 
     q[%(modal_verb)s be between %s and %s],
     q[%(modal_verb)s antara %s dan %s],
 
     q[%(modal_verb)s be larger than %s and smaller than %s],
     q[%(modal_verb)s lebih besar dari %s dan lebih kecil dari %s],
 
 
     q[undefined value],
     q[nilai tak terdefinisi],
 
     q[undefined values],
     q[nilai tak terdefinisi],
 
 
     q[%(modal_verb)s be %s],
     q[%(modal_verb)s %s],
 
     q[as well as %s],
     q[juga %s],
 
     q[%(modal_verb)s be all of the following],
     q[%(modal_verb)s merupakan semua ini],
 
 
     q[%(modal_verb)s be either %s],
     q[%s],
 
     q[or %s],
     q[atau %s],
 
     q[%(modal_verb)s be one of the following],
     q[%(modal_verb)s merupakan salah satu dari],
 
 
     q[array],
     q[larik],
 
     q[arrays],
     q[larik],
 
     q[%s of %s],
     q[%s %s],
 
     q[each array element %(modal_verb)s be],
     q[setiap elemen larik %(modal_verb)s],
 
     q[%s %(modal_verb)s be],
     q[%s %(modal_verb)s],
 
     q[element],
     q[elemen],
 
     q[each array subscript %(modal_verb)s be],
     q[setiap subskrip larik %(modal_verb)s],
 
 
     q[boolean value],
     q[nilai boolean],
 
     q[boolean values],
     q[nilai boolean],
 
     q[%(modal_verb)s be true],
     q[%(modal_verb)s bernilai benar],
 
     q[%(modal_verb)s be false],
     q[%(modal_verb)s bernilai salah],
 
 
     q[code],
     q[kode],
 
     q[codes],
     q[kode],
 
 
     q[decimal number],
     q[bilangan desimal],
 
     q[decimal numbers],
     q[bilangan desimal],
 
     q[%(modal_verb)s be a NaN],
     q[%(modal_verb)s NaN],
 
     q[%(modal_verb_neg)s be a NaN],
     q[%(modal_verb_neg)s NaN],
 
     q[%(modal_verb)s be an infinity],
     q[%(modal_verb)s tak hingga],
 
     q[%(modal_verb_neg)s be an infinity],
     q[%(modal_verb_neg)s tak hingga],
 
     q[%(modal_verb)s be a positive infinity],
     q[%(modal_verb)s positif tak hingga],
 
     q[%(modal_verb_neg)s be a positive infinity],
     q[%(modal_verb_neg)s positif tak hingga],
 
     q[%(modal_verb)s be a negative infinity],
     q[%(modal_verb)s negatif tak hingga],
 
     q[%(modal_verb)s be a negative infinity],
     q[%(modal_verb)s negatif tak hingga],
 
 
     q[hash],
     q[hash],
 
     q[hashes],
     q[hash],
 
     q[field %s %(modal_verb)s be],
     q[field %s %(modal_verb)s],
 
     q[field name %(modal_verb)s be],
     q[nama field %(modal_verb)s],
 
     q[each field %(modal_verb)s be],
     q[setiap field %(modal_verb)s],
 
     q[hash contains unknown field(s) (%s)],
     q[hash mengandung field yang tidak dikenali (%s)],
 
     q[hash contains unknown field(s) (%s)],
     q[hash mengandung field yang tidak dikenali (%s)],
 
     q[%(modal_verb)s have required fields %s],
     q[%(modal_verb)s mengandung field wajib %s],
 
     q[hash has missing required field(s) (%s)],
     q[hash kekurangan field wajib (%s)],
 
     q[%(modal_verb)s have %s in its field values],
     q[%(modal_verb)s mengandung %s di nilai field],
 
     q[%(modal_verb)s only have these allowed fields %s],
     q[%(modal_verb)s hanya mengandung field yang diizinkan %s],
 
     q[%(modal_verb)s only have fields matching regex pattern %s],
     q[%(modal_verb)s hanya mengandung field yang namanya mengikuti pola regex %s],
 
     q[%(modal_verb_neg)s have these forbidden fields %s],
     q[%(modal_verb_neg)s mengandung field yang dilarang %s],
 
     q[%(modal_verb_neg)s have fields matching regex pattern %s],
     q[%(modal_verb_neg)s mengandung field yang namanya mengikuti pola regex %s],
 
     q[hash contains non-allowed field(s) (%s)],
     q[hash mengandung field yang tidak diizinkan (%s)],
 
     q[hash contains forbidden field(s) (%s)],
     q[hash mengandung field yang dilarang (%s)],
 
     q[fields whose names match regex pattern %s %(modal_verb)s be],
     q[field yang namanya cocok dengan pola regex %s %(modal_verb)s],
 
 
     q[integer],
     q[bilangan bulat],
 
     q[integers],
     q[bilangan bulat],
 
     q[%(modal_verb)s be divisible by %s],
     q[%(modal_verb)s dapat dibagi oleh %s],
 
     q[%(modal_verb)s be odd],
     q[%(modal_verb)s ganjil],
 
     q[%(modal_verb)s be even],
     q[%(modal_verb)s genap],
 
     q[%(modal_verb)s leave a remainder of %2$s when divided by %1$s],
     q[jika dibagi %1$s %(modal_verb)s menyisakan %2$s],
 
 
     q[number],
     q[bilangan],
 
     q[numbers],
     q[bilangan],
 
 
     q[object],
     q[objek],
 
     q[objects],
     q[objek],
 
 
     q[regex pattern],
     q[pola regex],
 
     q[regex patterns],
     q[pola regex],
 
 
     q[text],
     q[teks],
 
     q[texts],
     q[teks],
 
     q[%(modal_verb)s match regex pattern %s],
     q[%(modal_verb)s cocok dengan pola regex %s],
 
     q[%(modal_verb)s be a regex pattern],
     q[%(modal_verb)s pola regex],
 
     q[each subscript of text %(modal_verb)s be],
     q[setiap subskrip dari teks %(modal_verb)s],
 
     q[each character of the text %(modal_verb)s be],
     q[setiap karakter dari teks %(modal_verb)s],
 
     q[character],
     q[karakter],
 
 
 
     q[buffer],
     q[buffer],
 
     q[buffers],
     q[buffer],
 
 
     q[Does not satisfy the following schema: %s],
     q[Tidak memenuhi skema ini: %s],
 
     q[Not of type %s],
     q[Tidak bertipe %s],
 
     q[Required but not specified],
     q[Wajib tapi belum diisi],
 
     q[Forbidden but specified],
     q[Dilarang tapi diisi],
 
     q[Structure contains unknown field(s) [%%s]],
     q[Struktur mengandung field yang tidak dikenal [%%s]],
 
 );
 
 1;
 
 __END__
 
### Data/Sah/Lang/zh_CN.pm ###
 package Data::Sah::Lang::zh_CN;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Tie::IxHash;
 
 
 our %translations;
 tie %translations, 'Tie::IxHash', (
 
 
     q[ ], 
     q[],
 
     q[, ],
     q[，],
 
     q[: ],
     q[：],
 
     q[. ],
     q[。],
 
     q[(],
     q[（],
 
     q[)],
     q[）],
 
 
     q[must],
     q[必须],
 
     q[must not],
     q[必须不],
 
     q[should],
     q[应],
 
     q[should not],
     q[应不],
 
 
     q[field],
     q[字段],
 
     q[fields],
     q[字段],
 
     q[argument],
     q[参数],
 
     q[arguments],
     q[参数],
 
 
     q[%s and %s],
     q[%s和%s],
 
     q[%s or %s],
     q[%s或%s],
 
     q[one of %s],
     q[这些值%s之一],
 
     q[all of %s],
     q[所有这些值%s],
 
     q[%(modal_verb)s satisfy all of the following],
     q[%(modal_verb)s满足所有这些条件],
 
     q[%(modal_verb)s satisfy one of the following],
     q[%(modal_verb)s满足这些条件之一],
 
     q[%(modal_verb)s satisfy none of the following],
     q[%(modal_verb_neg)s满足所有这些条件],
 
 
 
 
 
 
 
     q[integer],
     q[整数],
 
     q[integers],
     q[整数],
 
     q[%(modal_verb)s be divisible by %s],
     q[%(modal_verb)s被%s整除],
 
     q[%(modal_verb)s leave a remainder of %2$s when divided by %1$s],
     q[除以%1$s时余数%(modal_verb)s为%2$s],
 
 );
 
 1;
 
 __END__
 
### Data/Sah/Normalize.pm ###
 package Data::Sah::Normalize;
 
 use 5.010001;
 use strict;
 use warnings;
 
 our $DATE = '2015-09-06'; 
 our $VERSION = '0.04'; 
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(
                        normalize_clset
                        normalize_schema
 
                        $type_re
                        $clause_name_re
                        $clause_re
                        $attr_re
                        $funcset_re
                        $compiler_re
                );
 
 our $type_re        = qr/\A(?:[A-Za-z_]\w*::)*[A-Za-z_]\w*\z/;
 our $clause_name_re = qr/\A[A-Za-z_]\w*\z/;
 our $clause_re      = qr/\A[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*\z/;
 our $attr_re        = $clause_re;
 our $funcset_re     = qr/\A(?:[A-Za-z_]\w*::)*[A-Za-z_]\w*\z/;
 our $compiler_re    = qr/\A[A-Za-z_]\w*\z/;
 our $clause_attr_on_empty_clause_re = qr/\A(?:\.[A-Za-z_]\w*)+\z/;
 
 sub normalize_clset($;$) {
     my ($clset0, $opts) = @_;
     $opts //= {};
 
     my $clset = {};
     for my $c (sort keys %$clset0) {
         my $c0 = $c;
 
         my $v = $clset0->{$c};
 
         my $expr;
         if ($c =~ s/=\z//) {
             $expr++;
             die "Conflict between '$c=' and '$c'" if exists $clset0->{$c};
             $clset->{"$c.is_expr"} = 1;
             }
 
         my $sc = "";
         my $cn;
         {
             my $errp = "Invalid clause name syntax '$c0'"; 
             if (!$expr && $c =~ s/\A!(?=.)//) {
                 die "$errp, syntax should be !CLAUSE"
                     unless $c =~ $clause_name_re;
                 $sc = "!";
             } elsif (!$expr && $c =~ s/(?<=.)\|\z//) {
                 die "$errp, syntax should be CLAUSE|"
                     unless $c =~ $clause_name_re;
                 $sc = "|";
             } elsif (!$expr && $c =~ s/(?<=.)\&\z//) {
                 die "$errp, syntax should be CLAUSE&"
                     unless $c =~ $clause_name_re;
                 $sc = "&";
             } elsif (!$expr && $c =~ /\A([^.]+)(?:\.(.+))?\((\w+)\)\z/) {
                 my ($c2, $a, $lang) = ($1, $2, $3);
                 die "$errp, syntax should be CLAUSE(LANG) or C.ATTR(LANG)"
                     unless $c2 =~ $clause_name_re &&
                         (!defined($a) || $a =~ $attr_re);
                 $sc = "(LANG)";
                 $cn = $c2 . (defined($a) ? ".$a" : "") . ".alt.lang.$lang";
             } elsif ($c !~ $clause_re &&
                          $c !~ $clause_attr_on_empty_clause_re) {
                 die "$errp, please use letter/digit/underscore only";
             }
         }
 
         if ($sc eq '!') {
             die "Conflict between clause shortcuts '!$c' and '$c'"
                 if exists $clset0->{$c};
             die "Conflict between clause shortcuts '!$c' and '$c|'"
                 if exists $clset0->{"$c|"};
             die "Conflict between clause shortcuts '!$c' and '$c&'"
                 if exists $clset0->{"$c&"};
             $clset->{$c} = $v;
             $clset->{"$c.op"} = "not";
         } elsif ($sc eq '&') {
             die "Conflict between clause shortcuts '$c&' and '$c'"
                 if exists $clset0->{$c};
             die "Conflict between clause shortcuts '$c&' and '$c|'"
                 if exists $clset0->{"$c|"};
             die "Clause 'c&' value must be an array"
                 unless ref($v) eq 'ARRAY';
             $clset->{$c} = $v;
             $clset->{"$c.op"} = "and";
         } elsif ($sc eq '|') {
             die "Conflict between clause shortcuts '$c|' and '$c'"
                 if exists $clset0->{$c};
             die "Clause 'c|' value must be an array"
                 unless ref($v) eq 'ARRAY';
             $clset->{$c} = $v;
             $clset->{"$c.op"} = "or";
         } elsif ($sc eq '(LANG)') {
             die "Conflict between clause '$c' and '$cn'"
                 if exists $clset0->{$cn};
             $clset->{$cn} = $v;
         } else {
             $clset->{$c} = $v;
         }
 
     }
     $clset->{req} = 1 if $opts->{has_req};
 
 
     $clset;
 }
 
 sub normalize_schema($) {
     my $s = shift;
 
     my $ref = ref($s);
     if (!defined($s)) {
 
         die "Schema is missing";
 
     } elsif (!$ref) {
 
         my $has_req = $s =~ s/\*\z//;
         $s =~ $type_re or die "Invalid type syntax $s, please use ".
             "letter/digit/underscore only";
         return [$s, $has_req ? {req=>1} : {}, {}];
 
     } elsif ($ref eq 'ARRAY') {
 
         my $t = $s->[0];
         my $has_req = $t && $t =~ s/\*\z//;
         if (!defined($t)) {
             die "For array form, at least 1 element is needed for type";
         } elsif (ref $t) {
             die "For array form, first element must be a string";
         }
         $t =~ $type_re or die "Invalid type syntax $s, please use ".
             "letter/digit/underscore only";
 
         my $clset0;
         my $extras;
         if (defined($s->[1])) {
             if (ref($s->[1]) eq 'HASH') {
                 $clset0 = $s->[1];
                 $extras = $s->[2];
                 die "For array form, there should not be more than 3 elements"
                     if @$s > 3;
             } else {
                 die "For array in the form of [t, c1=>1, ...], there must be ".
                     "3 elements (or 5, 7, ...)"
                         unless @$s % 2;
                 $clset0 = { @{$s}[1..@$s-1] };
             }
         } else {
             $clset0 = {};
         }
 
         my $clset = normalize_clset($clset0, {has_req=>$has_req});
         if (defined $extras) {
             die "For array form with 3 elements, extras must be hash"
                 unless ref($extras) eq 'HASH';
             die "'def' in extras must be a hash"
                 if exists $extras->{def} && ref($extras->{def}) ne 'HASH';
             return [$t, $clset, { %{$extras} }];
         } else {
             return [$t, $clset, {}];
         }
     }
 
     die "Schema must be a string or arrayref (not $ref)";
 }
 
 1;
 
 __END__
 
### Data/Sah/Type/BaseType.pm ###
 package Data::Sah::Type::BaseType;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 
 requires 'handle_type';
 
 has_clause 'v',
     prio=>0, tags=>['meta', 'defhash'],
     arg=>['float*'=>{is=>1}];
 
 has_clause 'defhash_v',
     prio=>0, tags=>['meta', 'defhash'],
     arg=>['float*'=>{is=>1}];
 
 has_clause 'schema_v',
     prio=>0, tags=>['meta'],
     arg=>['float*'=>{}];
 
 has_clause 'base_v',
     prio=>0, tags=>['meta'],
     arg=>['float*'=>{}];
 
 has_clause 'ok',
     tags       => ['constraint'],
     prio       => 1,
     arg        => 'any',
     allow_expr => 1,
     ;
 has_clause 'default',
     prio       => 1,
     tags       => [],
     arg        => 'any',
     allow_expr => 1,
     attrs      => {
         temp => {
             arg        => [bool => default=>0],
             allow_expr => 0,
         },
     },
     ;
 has_clause 'default_lang',
     tags       => ['meta', 'defhash'],
     prio       => 2,
     arg        => ['str*'=>{default=>'en_US'}],
     ;
 has_clause 'name',
     tags       => ['meta', 'defhash'],
     prio       => 2,
     arg        => 'str*'
     ;
 has_clause 'summary',
     prio       => 2,
     tags       => ['meta', 'defhash'],
     arg        => 'str*',
     ;
 has_clause 'description',
     tags       => ['meta', 'defhash'],
     prio       => 2,
     arg        => 'str*',
     ;
 has_clause 'tags',
     tags       => ['meta', 'defhash'],
     prio       => 2,
     arg        => ['array*', of=>'str*'],
     ;
 has_clause 'req',
     tags       => ['constraint'],
     prio       => 3,
     arg        => 'bool',
     allow_expr => 1,
     ;
 has_clause 'forbidden',
     tags       => ['constraint'],
     prio       => 3,
     arg        => 'bool',
     allow_expr => 1,
     ;
 
 
 
 
 
 
 has_clause 'clause',
     tags       => ['constraint'],
     prio       => 50,
     arg        => ['array*' => elems => ['clname*', 'any']],
     ;
 has_clause 'clset',
     prio=>50, tags=>['constraint'],
     arg=>['clset*']
     ;
 
 1;
 
 __END__
 
### Data/Sah/Type/Comparable.pm ###
 package Data::Sah::Type::Comparable;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 
 requires 'superclause_comparable';
 
 has_clause 'in',
     tags       => ['constraint'],
     arg        => '(any[])*',
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_comparable('in', $cd);
     };
 has_clause 'is',
     tags       => ['constraint'],
     arg        => 'any',
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_comparable('is', $cd);
     };
 
 1;
 
 __END__
 
### Data/Sah/Type/HasElems.pm ###
 package Data::Sah::Type::HasElems;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 
 requires 'superclause_has_elems';
 
 has_clause 'max_len',
     prio       => 51,
     arg        => ['int*' => {min=>0}],
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_has_elems('max_len', $cd);
     };
 
 has_clause 'min_len',
     arg        => ['int*' => {min=>0}],
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_has_elems('min_len', $cd);
     };
 
 has_clause 'len_between',
     arg        => ['array*' => {elems => ['int*', 'int*']}],
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_has_elems('len_between', $cd);
     };
 
 has_clause 'len',
     arg        => ['int*' => {min=>0}],
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_has_elems('len', $cd);
     };
 
 has_clause 'has',
     arg        => 'any',
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_has_elems('has', $cd);
     };
 
 has_clause 'each_index',
     arg        => 'schema*',
     allow_expr => 0,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_has_elems('each_index', $cd);
     };
 
 has_clause 'each_elem',
     arg        => 'schema*',
     allow_expr => 0,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_has_elems('each_elem', $cd);
     };
 
 has_clause 'check_each_index',
     arg        => 'schema*',
     allow_expr => 0,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_has_elems('check_each_index', $cd);
     };
 
 has_clause 'check_each_elem',
     arg        => 'schema*',
     allow_expr => 0,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_has_elems('check_each_elem', $cd);
     };
 
 has_clause 'uniq',
     arg        => 'schema*',
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_has_elems('uniq', $cd);
     };
 
 has_clause 'exists',
     arg        => 'schema*',
     allow_expr => 0,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_has_elems('exists', $cd);
     };
 
 
 
 
 1;
 
 __END__
 
### Data/Sah/Type/Sortable.pm ###
 package Data::Sah::Type::Sortable;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 
 requires 'superclause_sortable';
 
 has_clause 'min',
     tags       => ['constraint'],
     arg        => 'any*',
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_sortable('min', $cd);
     },
     ;
 has_clause 'xmin',
     tags       => ['constraint'],
     arg        => 'any*',
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_sortable('xmin', $cd);
     },
     ;
 has_clause 'max',
     prio       => 51,
     tags       => ['constraint'],
     arg        => 'any*',
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_sortable('max', $cd);
     },
     ;
 has_clause 'xmax',
     prio       => 51,
     tags       => ['constraint'],
     arg        => 'any*',
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_sortable('xmax', $cd);
     },
     ;
 has_clause 'between',
     tags       => ['constraint'],
     arg        => '[any*, any*]*',
     allow_expr => 1,
     code       => sub {
         my ($self, $cd) = @_;
         $self->superclause_sortable('between', $cd);
     },
     ;
 has_clause 'xbetween',
     tags       => ['constraint'],
     arg        => '[any*, any*]*',
     allow_expr => 1,
     code => sub {
         my ($self, $cd) = @_;
         $self->superclause_sortable('xbetween', $cd);
     },
     ;
 
 1;
 
 __END__
 
### Data/Sah/Type/all.pm ###
 package Data::Sah::Type::all;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 
 has_clause 'of',
     tags       => ['constraint'],
     arg        => ['array*' => {min_len=>1, each_elem => 'schema*'}],
     allow_expr => 0,
     ;
 
 1;
 
 __END__
 
### Data/Sah/Type/any.pm ###
 package Data::Sah::Type::any;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 
 has_clause 'of',
     tags       => ['constraint'],
     arg        => ['array*' => {min_len=>1, each_elem => 'schema*'}],
     allow_expr => 0,
     ;
 
 1;
 
 __END__
 
### Data/Sah/Type/array.pm ###
 package Data::Sah::Type::array;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause', 'has_clause_alias';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 with 'Data::Sah::Type::Comparable';
 with 'Data::Sah::Type::HasElems';
 
 has_clause 'elems',
     tags       => ['constraint'],
     arg        => ['array*' => {of=>'schema*'}],
     allow_expr => 0,
     attrs      => {
         create_default => {
             arg        => [bool => default=>1],
             allow_expr => 0, 
         },
     },
     ;
 has_clause_alias each_elem => 'of';
 
 1;
 
 __END__
 
### Data/Sah/Type/bool.pm ###
 package Data::Sah::Type::bool;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 with 'Data::Sah::Type::Comparable';
 with 'Data::Sah::Type::Sortable';
 
 has_clause 'is_true',
     tags       => ['constraint'],
     arg        => 'bool',
     allow_expr => 1,
     ;
 
 1;
 
 __END__
 
### Data/Sah/Type/buf.pm ###
 package Data::Sah::Type::buf;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::str';
 
 1;
 
 __END__
 
### Data/Sah/Type/cistr.pm ###
 package Data::Sah::Type::cistr;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::str';
 
 1;
 
 __END__
 
### Data/Sah/Type/code.pm ###
 package Data::Sah::Type::code;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 
 1;
 
 __END__
 
### Data/Sah/Type/date.pm ###
 package Data::Sah::Type::date;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 with 'Data::Sah::Type::Comparable';
 with 'Data::Sah::Type::Sortable';
 
 
 1;
 
 __END__
 
### Data/Sah/Type/duration.pm ###
 package Data::Sah::Type::duration;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 
 
 1;
 
 __END__
 
### Data/Sah/Type/float.pm ###
 package Data::Sah::Type::float;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::num';
 
 has_clause 'is_nan',
     tags        => ['constraint'],
     arg         => ['bool'],
     allow_expr  => 1,
     allow_multi => 0,
     ;
 
 has_clause 'is_inf',
     tags        => ['constraint'],
     arg         => ['bool'],
     allow_expr  => 1,
     allow_multi => 1,
     ;
 
 has_clause 'is_pos_inf',
     tags        => ['constraint'],
     arg         => ['bool'],
     allow_expr  => 1,
     allow_multi => 1,
     ;
 
 has_clause 'is_neg_inf',
     tags        => ['constraint'],
     arg         => ['bool'],
     allow_expr  => 1,
     allow_multi => 1,
     ;
 
 1;
 
 __END__
 
### Data/Sah/Type/hash.pm ###
 package Data::Sah::Type::hash;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause', 'has_clause_alias';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 with 'Data::Sah::Type::Comparable';
 with 'Data::Sah::Type::HasElems';
 
 has_clause_alias each_elem => 'of';
 
 has_clause "keys",
     tags       => ['constraint'],
     arg        => ['hash*' => {values => 'schema*'}],
     allow_expr => 0,
     attrs      => {
         restrict => {
             arg        => [bool => default=>1],
             allow_expr => 0, 
         },
         create_default => {
             arg        => [bool => default=>1],
             allow_expr => 0, 
         },
     },
     ;
 has_clause "re_keys",
     prio       => 51,
     tags       => ['constraint'],
     arg        => ['hash*' => {keys => 're*', values => 'schema*'}],
     allow_expr => 0,
     attrs      => {
         restrict => {
             arg        => [bool => default=>1],
             allow_expr => 0, 
         },
     },
     ;
 has_clause "req_keys",
     tags       => ['constraint'],
     arg        => ['array*'],
     allow_expr => 1,
     ;
 has_clause "allowed_keys",
     tags       => ['constraint'],
     arg        => ['array*'],
     allow_expr => 1,
     ;
 has_clause "allowed_keys_re",
     prio       => 51,
     tags       => ['constraint'],
     arg        => 're*',
     allow_expr => 1,
     ;
 has_clause "forbidden_keys",
     tags       => ['constraint'],
     arg        => ['array*'],
     allow_expr => 1,
     ;
 has_clause "forbidden_keys_re",
     prio       => 51,
     tags       => ['constraint'],
     arg        => 're*',
     allow_expr => 1,
     ;
 has_clause_alias each_index => 'each_key';
 has_clause_alias each_elem => 'each_value';
 has_clause_alias check_each_index => 'check_each_key';
 has_clause_alias check_each_elem => 'check_each_value';
 
 has_clause "choose_one_key",
     prio       => 50,
     tags       => ['constraint'],
     arg        => ['array*', {of=>'str*', min_len=>1}],
     allow_expr => 0, 
     ;
 has_clause_alias choose_one_key => 'choose_one';
 has_clause "choose_all_keys",
     prio       => 50,
     tags       => ['constraint'],
     arg        => ['array*', {of=>'str*', min_len=>1}],
     allow_expr => 0, 
     ;
 has_clause_alias choose_all_keys => 'choose_all';
 has_clause "req_one_key",
     prio       => 50,
     tags       => ['constraint'],
     arg        => ['array*', {of=>'str*', min_len=>1}],
     allow_expr => 0, 
     ;
 has_clause_alias req_one_key => 'req_one';
 has_clause_alias req_keys => 'req_all_keys';
 has_clause_alias req_keys => 'req_all';
 
 my $dep_arg = ['array*', {elems=>[ 'str*', ['array*',of=>'str*'] ]}];
 
 has_clause "dep_any",
     prio       => 50,
     tags       => ['constraint'],
     arg        => $dep_arg,
     allow_expr => 0, 
     ;
 has_clause "dep_all",
     prio       => 50,
     tags       => ['constraint'],
     arg        => $dep_arg,
     allow_expr => 0, 
     ;
 has_clause "req_dep_any",
     prio       => 50,
     tags       => ['constraint'],
     arg        => $dep_arg,
     allow_expr => 0, 
     ;
 has_clause "req_dep_all",
     prio       => 50,
     tags       => ['constraint'],
     arg        => $dep_arg,
     allow_expr => 0, 
     ;
 
 
 
 1;
 
 __END__
 
### Data/Sah/Type/int.pm ###
 package Data::Sah::Type::int;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::num';
 
 has_clause 'mod',
     tags       => ['constraint'],
     arg        => ['array*' => {elems => [['int*' => {'!is'=>0}], 'int*']}],
     allow_expr => 1,
     ;
 has_clause 'div_by',
     tags       => ['constraint'],
     arg        => ['int*' => {'!is'=>0}],
     allow_expr => 1,
     ;
 
 1;
 
 __END__
 
### Data/Sah/Type/num.pm ###
 package Data::Sah::Type::num;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 with 'Data::Sah::Type::Comparable';
 with 'Data::Sah::Type::Sortable';
 
 1;
 
 __END__
 
### Data/Sah/Type/obj.pm ###
 package Data::Sah::Type::obj;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 
 has_clause 'can',
     tags       => ['constraint'],
     arg        => 'str*', 
     allow_expr => 1,
     ;
 has_clause 'isa',
     tags       => ['constraint'],
     arg        => 'str*', 
     allow_expr => 1,
     ;
 
 1;
 
 __END__
 
### Data/Sah/Type/re.pm ###
 package Data::Sah::Type::re;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 
 1;
 
 __END__
 
### Data/Sah/Type/str.pm ###
 package Data::Sah::Type::str;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Data::Sah::Util::Role 'has_clause';
 use Role::Tiny;
 use Role::Tiny::With;
 
 with 'Data::Sah::Type::BaseType';
 with 'Data::Sah::Type::Comparable';
 with 'Data::Sah::Type::Sortable';
 with 'Data::Sah::Type::HasElems';
 
 my $t_re = 'regex*|{*=>regex*}';
 
 has_clause 'encoding',
     tags       => ['constraint'],
     arg        => 'str*',
     allow_expr => 0,
     ;
 has_clause 'match',
     tags       => ['constraint'],
     arg        => $t_re,
     allow_expr => 1,
     ;
 has_clause 'is_re',
     tags       => ['constraint'],
     arg        => 'bool',
     allow_expr => 1,
     ;
 
 1;
 
 __END__
 
### Data/Sah/Type/undef.pm ###
 package Data::Sah::Type::undef;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use Role::Tiny;
 use Data::Sah::Util::Role 'has_clause';
 
 1;
 
 __END__
 
### Data/Sah/Util/Func.pm ###
 package Data::Sah::Util::Func;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        add_func
                );
 
 sub add_func {
     my ($funcset, $func, %opts) = @_;
 }
 
 1;
 
 __END__
 
### Data/Sah/Util/Role.pm ###
 package Data::Sah::Util::Role;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Sub::Install qw(install_sub);
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        has_clause has_clause_alias
                        has_func   has_func_alias
                );
 
 sub has_clause {
     my ($name, %args) = @_;
     my $caller = caller;
     my $into   = $args{into} // $caller;
 
     if ($args{code}) {
         install_sub({code => $args{code}, into => $into,
                      as => "clause_$name"});
     } else {
         eval "package $into; use Role::Tiny; ".
             "requires 'clause_$name';";
     }
     install_sub({code => sub {
                      state $meta = {
                          names      => [$name],
                          tags       => $args{tags},
                          prio       => $args{prio} // 50,
                          arg        => $args{arg},
                          allow_expr => $args{allow_expr},
                          attrs      => $args{attrs} // {},
                      };
                      $meta;
                  },
                  into => $into,
                  as => "clausemeta_$name"});
     has_clause_alias($name, $args{alias}  , $into);
     has_clause_alias($name, $args{aliases}, $into);
 }
 
 sub has_clause_alias {
     my ($name, $aliases, $into) = @_;
     my $caller   = caller;
     $into      //= $caller;
     my @aliases = !$aliases ? () :
         ref($aliases) eq 'ARRAY' ? @$aliases : $aliases;
     my $meta = $into->${\("clausemeta_$name")};
 
     for my $alias (@aliases) {
         push @{ $meta->{names} }, $alias;
         eval
             "package $into;".
             "sub clause_$alias { shift->clause_$name(\@_) } ".
             "sub clausemeta_$alias { shift->clausemeta_$name(\@_) } ";
         $@ and die "Can't make clause alias $alias -> $name: $@";
     }
 }
 
 sub has_func {
     my ($name, %args) = @_;
     my $caller = caller;
     my $into   = $args{into} // $caller;
 
     if ($args{code}) {
         install_sub({code => $args{code}, into => $into, as => "func_$name"});
     } else {
         eval "package $into; use Role::Tiny; requires 'func_$name';";
     }
     install_sub({code => sub {
                      state $meta = {
                          names => [$name],
                          args  => $args{args},
                      };
                      $meta;
                  },
                  into => $into,
                  as => "funcmeta_$name"});
     my @aliases =
         map { (!$args{$_} ? () :
                    ref($args{$_}) eq 'ARRAY' ? @{ $args{$_} } : $args{$_}) }
             qw/alias aliases/;
     has_func_alias($name, $args{alias}  , $into);
     has_func_alias($name, $args{aliases}, $into);
 }
 
 sub has_func_alias {
     my ($name, $aliases, $into) = @_;
     my $caller   = caller;
     $into      //= $caller;
     my @aliases = !$aliases ? () :
         ref($aliases) eq 'ARRAY' ? @$aliases : $aliases;
     my $meta = $into->${\("funcmeta_$name")};
 
     for my $alias (@aliases) {
         push @{ $meta->{names} }, $alias;
         eval
             "package $into;".
             "sub func_$alias { shift->func_$name(\@_) } ".
             "sub funcmeta_$alias { shift->funcmeta_$name(\@_) } ";
         $@ and die "Can't make func alias $alias -> $name: $@";
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Util/Type.pm ###
 package Data::Sah::Util::Type;
 
 our $DATE = '2015-01-20'; 
 our $VERSION = '0.42'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(get_type is_simple is_numeric is_collection is_ref);
 
 my $type_metas = {
     all   => {scalar=>0, numeric=>0, ref=>0},
     any   => {scalar=>0, numeric=>0, ref=>0},
     array => {scalar=>0, numeric=>0, ref=>1},
     bool  => {scalar=>1, numeric=>0, ref=>0},
     buf   => {scalar=>1, numeric=>0, ref=>0},
     cistr => {scalar=>1, numeric=>0, ref=>0},
     code  => {scalar=>1, numeric=>0, ref=>1},
     float => {scalar=>1, numeric=>1, ref=>0},
     hash  => {scalar=>0, numeric=>0, ref=>1},
     int   => {scalar=>1, numeric=>1, ref=>0},
     num   => {scalar=>1, numeric=>1, ref=>0},
     obj   => {scalar=>1, numeric=>0, ref=>1},
     re    => {scalar=>1, numeric=>0, ref=>1, simple=>1},
     str   => {scalar=>1, numeric=>0, ref=>0},
     undef => {scalar=>1, numeric=>0, ref=>0},
 };
 
 sub get_type {
     my $sch = shift;
 
     if (ref($sch) eq 'ARRAY') {
         $sch = $sch->[0];
     }
 
     if (defined($sch) && !ref($sch)) {
         $sch =~ s/\*\z//;
         return $sch;
     } else {
         return undef;
     }
 }
 
 sub _normalize {
     require Data::Sah::Normalize;
 
     my ($sch, $opts) = @_;
     return $sch if $opts->{schema_is_normalized};
     return Data::Sah::Normalize::normalize_schema($sch);
 }
 
 sub _handle_any_all {
     my ($sch, $opts, $crit) = @_;
     $sch = _normalize($sch, $opts);
     return 0 if $sch->[1]{'of.op'};
     my $of = $sch->[1]{of};
     return 0 unless $of && ref($of) eq 'ARRAY' && @$of;
     for (@$of) {
         return 0 unless $crit->($_);
     }
     1;
 }
 
 sub is_simple {
     my ($sch, $opts) = @_;
     $opts //= {};
 
     my $type = get_type($sch) or return undef;
     my $tmeta = $type_metas->{$type} or return undef;
     if ($type eq 'any' || $type eq 'all') {
         return _handle_any_all($sch, $opts, sub { is_simple(shift) });
     }
     return $tmeta->{simple} // ($tmeta->{scalar} && !$tmeta->{ref});
 }
 
 sub is_collection {
     my ($sch, $opts) = @_;
     $opts //= {};
 
     my $type = get_type($sch) or return undef;
     my $tmeta = $type_metas->{$type} or return undef;
     if ($type eq 'any' || $type eq 'all') {
         return _handle_any_all($sch, $opts, sub { is_collection(shift) });
     }
     return !$tmeta->{scalar};
 }
 
 sub is_numeric {
     my ($sch, $opts) = @_;
     $opts //= {};
 
     my $type = get_type($sch) or return undef;
     my $tmeta = $type_metas->{$type} or return undef;
     if ($type eq 'any' || $type eq 'all') {
         return _handle_any_all($sch, $opts, sub { is_numeric(shift) });
     }
     return $tmeta->{numeric};
 }
 
 sub is_ref {
     my ($sch, $opts) = @_;
     $opts //= {};
 
     my $type = get_type($sch) or return undef;
     my $tmeta = $type_metas->{$type} or return undef;
     if ($type eq 'any' || $type eq 'all') {
         return _handle_any_all($sch, $opts, sub { is_ref(shift) });
     }
     return $tmeta->{ref};
 }
 
 1;
 
 __END__
 
### Data/Sah/Util/Type/Date.pm ###
 package Data::Sah::Util::Type::Date;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Scalar::Util qw(blessed looks_like_number);
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        coerce_date
                        coerce_duration
                );
 
 our $DATE_MODULE = $ENV{DATA_SAH_DATE_MODULE} // $ENV{PERL_DATE_MODULE} //
     "DateTime"; 
 
 my $re_ymd = qr/\A([0-9]{4})-([0-9]{2})-([0-9]{2})\z/;
 my $re_ymdThmsZ = qr/\A([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})Z\z/;
 
 sub coerce_date {
     my $val = shift;
     if (!defined($val)) {
         return undef;
     }
 
     if ($DATE_MODULE eq 'DateTime') {
         require DateTime;
         if (blessed($val) && $val->isa('DateTime')) {
             return $val;
         } elsif (looks_like_number($val) && $val >= 10**8 && $val <= 2**31) {
             return DateTime->from_epoch(epoch => $val);
         } elsif ($val =~ $re_ymd) {
             my $d;
             eval { $d = DateTime->new(year=>$1, month=>$2, day=>$3, time_zone=>'UTC') };
             return undef if $@;
             return $d;
         } elsif ($val =~ $re_ymdThmsZ) {
             my $d;
             eval { $d = DateTime->new(year=>$1, month=>$2, day=>$3, hour=>$4, minute=>$5, second=>$6, time_zone=>'UTC') };
             return undef if $@;
             return $d;
         } elsif (blessed($val) && $val->isa('Time::Moment')) {
             return DateTime->from_epoch(epoch => $val->epoch);
         } elsif (blessed($val) && $val->isa('Time::Piece')) {
             return DateTime->from_epoch(epoch => $val->epoch);
         } else {
             return undef;
         }
     } elsif ($DATE_MODULE eq 'Time::Moment') {
         require Time::Moment;
         if (blessed($val) && $val->isa('Time::Moment')) {
             return $val;
         } elsif (looks_like_number($val) && $val >= 10**8 && $val <= 2**31) {
             return Time::Moment->from_epoch(int($val), $val-int($val));
         } elsif ($val =~ $re_ymd) {
             my $d;
             eval { $d = Time::Moment->new(year=>$1, month=>$2, day=>$3) };
             return undef if $@;
             return $d;
         } elsif ($val =~ $re_ymdThmsZ) {
             my $d;
             eval { $d = Time::Moment->new(year=>$1, month=>$2, day=>$3, hour=>$4, minute=>$5, second=>$6) };
             return undef if $@;
             return $d;
         } elsif (blessed($val) && $val->isa('DateTime')) {
             return Time::Moment->from_epoch($val->epoch);
         } elsif (blessed($val) && $val->isa('Time::Piece')) {
             return Time::Moment->from_epoch($val->epoch);
         } else {
             return undef;
         }
     } elsif ($DATE_MODULE eq 'Time::Piece') {
         require Time::Piece;
         if (blessed($val) && $val->isa('Time::Piece')) {
             return $val;
         } elsif (looks_like_number($val) && $val >= 10**8 && $val <= 2**31) {
             return scalar Time::Piece->gmtime($val);
         } elsif ($val =~ $re_ymd) {
             my $d;
             eval { $d = Time::Piece->strptime($val, "%Y-%m-%d") };
             return undef if $@;
             return $d;
         } elsif ($val =~ $re_ymdThmsZ) {
             my $d;
             eval { $d = Time::Piece->strptime($val, "%Y-%m-%dT%H:%M:%SZ") };
             return undef if $@;
             return $d;
         } elsif (blessed($val) && $val->isa('DateTime')) {
             return scalar Time::Piece->gmtime(epoch => $val->epoch);
         } elsif (blessed($val) && $val->isa('Time::Moment')) {
             return scalar Time::Piece->gmtime(epoch => $val->epoch);
         } else {
             return undef;
         }
     } else {
         die "BUG: Unknown Perl date module '$DATE_MODULE'";
     }
 }
 
 sub coerce_duration {
     my $val = shift;
     if (!defined($val)) {
         return undef;
     } elsif (blessed($val) && $val->isa('DateTime::Duration')) {
         return $val;
     } elsif ($val =~ /\AP
                       (?: ([0-9]+(?:\.[0-9]+)?)Y )?
                       (?: ([0-9]+(?:\.[0-9]+)?)M )?
                       (?: ([0-9]+(?:\.[0-9]+)?)W )?
                       (?: ([0-9]+(?:\.[0-9]+)?)D )?
                       (?:
                           T
                           (?: ([0-9]+(?:\.[0-9]+)?)H )?
                           (?: ([0-9]+(?:\.[0-9]+)?)M )?
                           (?: ([0-9]+(?:\.[0-9]+)?)S )?
                       )?
                       \z/x) {
         require DateTime::Duration;
         my $d;
         eval {
             $d = DateTime::Duration->new(
                 years   => $1 // 0,
                 months  => $2 // 0,
                 weeks   => $3 // 0,
                 days    => $4 // 0,
                 hours   => $5 // 0,
                 minutes => $6 // 0,
                 seconds => $7 // 0,
             );
         };
         return undef if $@;
         return $d;
     } else {
         return undef;
     }
 }
 
 1;
 
 __END__
 
### Data/Sah/Util/TypeX.pm ###
 package Data::Sah::Util::TypeX;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        add_clause
                );
 
 sub add_clause {
     my ($type, $clause, %opts) = @_;
 
 
 }
 
 1;
 
 __END__
 
### Devel/GlobalDestruction.pm ###
 package Devel::GlobalDestruction;
 
 use strict;
 use warnings;
 
 our $VERSION = '0.13';
 
 use Sub::Exporter::Progressive -setup => {
   exports => [ qw(in_global_destruction) ],
   groups  => { default => [ -all ] },
 };
 
 if (defined ${^GLOBAL_PHASE}) {
   eval 'sub in_global_destruction () { ${^GLOBAL_PHASE} eq q[DESTRUCT] }; 1'
     or die $@;
 }
 elsif (eval {
   require Devel::GlobalDestruction::XS;
   no warnings 'once';
   *in_global_destruction = \&Devel::GlobalDestruction::XS::in_global_destruction;
   1;
 }) {
 }
 else {
   require B;
   eval 'sub in_global_destruction () { ${B::main_cv()} == 0 }; 1'
     or die $@;
 }
 
 1;  
 
 
 __END__
 
### Dist/CheckConflicts.pm ###
 package Dist::CheckConflicts;
 BEGIN {
   $Dist::CheckConflicts::AUTHORITY = 'cpan:DOY';
 }
 $Dist::CheckConflicts::VERSION = '0.11';
 use strict;
 use warnings;
 use 5.006;
 
 use base 'Exporter';
 our @EXPORT = our @EXPORT_OK = (
     qw(conflicts check_conflicts calculate_conflicts dist)
 );
 
 use Carp;
 use Module::Runtime 0.009 'module_notional_filename', 'require_module';
 
 
 my %CONFLICTS;
 my %HAS_CONFLICTS;
 my %DISTS;
 
 sub import {
     my $pkg = shift;
     my $for = caller;
 
     my ($conflicts, $alsos, $dist);
     ($conflicts, @_) = _strip_opt('-conflicts' => @_);
     ($alsos, @_)     = _strip_opt('-also' => @_);
     ($dist, @_)      = _strip_opt('-dist' => @_);
 
     my %conflicts = %{ $conflicts || {} };
     for my $also (@{ $alsos || [] }) {
         eval { require_module($also) } or next;
         if (!exists $CONFLICTS{$also}) {
             $also .= '::Conflicts';
             eval { require_module($also) } or next;
         }
         if (!exists $CONFLICTS{$also}) {
             next;
         }
         my %also_confs = $also->conflicts;
         for my $also_conf (keys %also_confs) {
             $conflicts{$also_conf} = $also_confs{$also_conf}
                 if !exists $conflicts{$also_conf}
                 || $conflicts{$also_conf} lt $also_confs{$also_conf};
         }
     }
 
     $CONFLICTS{$for} = \%conflicts;
     $DISTS{$for}     = $dist || $for;
 
     if (grep { $_ eq ':runtime' } @_) {
         for my $conflict (keys %conflicts) {
             $HAS_CONFLICTS{$conflict} ||= [];
             push @{ $HAS_CONFLICTS{$conflict} }, $for;
         }
 
         for my $conflict (keys %conflicts) {
             if (exists $INC{module_notional_filename($conflict)}) {
                 _check_version([$for], $conflict);
             }
         }
 
         @INC = grep {
             !(ref($_) eq 'ARRAY' && @$_ > 1 && $_->[1] == \%CONFLICTS)
         } @INC;
         unshift @INC, [
             sub {
                 my ($sub, $file) = @_;
 
                 (my $mod = $file) =~ s{\.pm$}{};
                 $mod =~ s{/}{::}g;
                 return unless $mod =~ /[\w:]+/;
 
                 return unless defined $HAS_CONFLICTS{$mod};
 
                 {
                     local $HAS_CONFLICTS{$mod};
                     require $file;
                 }
 
                 _check_version($HAS_CONFLICTS{$mod}, $mod);
 
                 my $called;
                 return sub {
                     return 0 if $called;
                     $_ = "1;";
                     $called = 1;
                     return 1;
                 };
             },
             \%CONFLICTS, 
         ];
     }
 
     $pkg->export_to_level(1, @_);
 }
 
 sub _strip_opt {
     my ($opt, @args) = @_;
 
     my $val;
     for my $idx ( 0 .. $#args - 1 ) {
         if (defined $args[$idx] && $args[$idx] eq $opt) {
             $val = (splice @args, $idx, 2)[1];
             last;
         }
     }
 
     return ( $val, @args );
 }
 
 sub _check_version {
     my ($fors, $mod) = @_;
 
     for my $for (@$fors) {
         my $conflict_ver = $CONFLICTS{$for}{$mod};
         my $version = do {
             no strict 'refs';
             ${ ${ $mod . '::' }{VERSION} };
         };
 
         if ($version le $conflict_ver) {
             warn <<EOF;
 Conflict detected for $DISTS{$for}:
   $mod is version $version, but must be greater than version $conflict_ver
 EOF
             return;
         }
     }
 }
 
 
 sub conflicts {
     my $package = shift;
     return %{ $CONFLICTS{ $package } };
 }
 
 
 sub dist {
     my $package = shift;
     return $DISTS{ $package };
 }
 
 
 sub check_conflicts {
     my $package = shift;
     my $dist = $package->dist;
     my @conflicts = $package->calculate_conflicts;
     return unless @conflicts;
 
     my $err = "Conflicts detected for $dist:\n";
     for my $conflict (@conflicts) {
         $err .= "  $conflict->{package} is version "
                 . "$conflict->{installed}, but must be greater than version "
                 . "$conflict->{required}\n";
     }
     die $err;
 }
 
 
 sub calculate_conflicts {
     my $package = shift;
     my %conflicts = $package->conflicts;
 
     my @ret;
 
 
     CONFLICT:
     for my $conflict (keys %conflicts) {
         my $success = do {
             local $SIG{__WARN__} = sub {};
             eval { require_module($conflict) };
         };
         my $error = $@;
         my $file = module_notional_filename($conflict);
         next if not $success and $error =~ /Can't locate \Q$file\E in \@INC/;
 
         warn "Warning: $conflict did not compile" if not $success;
         my $installed = $success ? $conflict->VERSION : 'unknown';
         push @ret, {
             package   => $conflict,
             installed => $installed,
             required  => $conflicts{$conflict},
         } if not $success or $installed le $conflicts{$conflict};
     }
 
     return sort { $a->{package} cmp $b->{package} } @ret;
 }
 
 
 1;
 
 __END__
 
### Exporter/Lite.pm ###
 package Exporter::Lite;
 
 require 5.006;
 use warnings;
 use strict;
 
 our $VERSION = '0.06';
 our @EXPORT = qw(import);
 
 
 sub import {
     my($exporter, @imports)  = @_;
     my($caller, $file, $line) = caller;
 
     no strict 'refs';
 
     unless( @imports ) {        
         @imports = @{$exporter.'::EXPORT'};
     }
     else {
         my $eokglob;
         if( $eokglob = ${$exporter.'::'}{EXPORT_OK} and *$eokglob{ARRAY} ) {
             if( @{$exporter.'::EXPORT_OK'} ) {
                 my %ok = map { s/^&//; $_ => 1 } @{$exporter.'::EXPORT_OK'},
                                                  @{$exporter.'::EXPORT'};
 
                 my($denied) = grep {s/^&//; !$ok{$_}} @imports;
                 _not_exported($denied, $exporter, $file, $line) if $denied;
             }
             else {      
                 _not_exported($imports[0], $exporter, $file, $line);
             }
         }
     }
 
     _export($caller, $exporter, @imports);
 }
 
 
 
 sub _export {
     my($caller, $exporter, @imports) = @_;
 
     no strict 'refs';
 
     foreach my $sym (@imports) {
         (*{$caller.'::'.$sym} = \&{$exporter.'::'.$sym}, next)
             unless $sym =~ s/^(\W)//;
 
         my $type = $1;
         my $caller_sym = $caller.'::'.$sym;
         my $export_sym = $exporter.'::'.$sym;
         *{$caller_sym} =
             $type eq '&' ? \&{$export_sym} :
             $type eq '$' ? \${$export_sym} :
             $type eq '@' ? \@{$export_sym} :
             $type eq '%' ? \%{$export_sym} :
             $type eq '*' ?  *{$export_sym} :
             do { require Carp; Carp::croak("Can't export symbol: $type$sym") };
     }
 }
 
 
 sub _not_exported {
     my($thing, $exporter, $file, $line) = @_;
     die sprintf qq|"%s" is not exported by the %s module at %s line %d\n|,
         $thing, $exporter, $file, $line;
 }
 
 1;
 
 __END__
 
### File/Flock/Retry.pm ###
 package File::Flock::Retry;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.60'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Fcntl ':flock';
 
 sub lock {
     my ($class, $path, $opts) = @_;
     $opts //= {};
     my %h;
 
     defined($path) or die "Please specify path";
     $h{path}    = $path;
     $h{retries} = $opts->{retries} // 60;
 
     my $self = bless \%h, $class;
     $self->_lock;
     $self;
 }
 
 sub _lock {
     my $self = shift;
 
     return 0 if $self->{_fh};
 
     my $path = $self->{path};
     my $existed = -f $path;
     my $exists;
     my $tries = 0;
   TRY:
     while (1) {
         $tries++;
 
         open $self->{_fh}, ">>", $path
             or die "Can't open lock file '$path': $!";
 
         my @st1 = stat($self->{_fh}); 
 
         if (flock($self->{_fh}, LOCK_EX | LOCK_NB)) {
             redo TRY unless @st1;
 
             my @st2 = stat($path); 
 
             redo TRY unless @st2;
 
             redo TRY if $st1[0] != $st2[0] || $st1[1] != $st2[1];
 
             last;
         } else {
             $tries <= $self->{retries}
                 or die "Can't acquire lock on '$path' after $tries seconds";
             sleep 1;
         }
     }
     $self->{_created} = !$existed;
     1;
 }
 
 sub _unlock {
     my ($self) = @_;
 
     my $path = $self->{path};
 
     return 0 unless $self->{_fh};
 
     unlink $self->{path} if $self->{_created} && !(-s $self->{path});
 
     {
         no warnings;
 
         flock $self->{_fh}, LOCK_UN;
     }
     close delete($self->{_fh});
     1;
 }
 
 sub release {
     my $self = shift;
     $self->_unlock;
 }
 
 sub unlock {
     my $self = shift;
     $self->_unlock;
 }
 
 sub DESTROY {
     my $self = shift;
     $self->_unlock;
 }
 
 1;
 
 __END__
 
### File/HomeDir.pm ###
 package File::HomeDir;
 
 
 use 5.00503;
 use strict;
 use Carp        ();
 use Config      ();
 use File::Spec  ();
 use File::Which ();
 
 use vars qw{$VERSION @ISA @EXPORT @EXPORT_OK $IMPLEMENTED_BY};
 BEGIN {
 	$VERSION = '1.00';
 
 	require Exporter;
 	@ISA       = qw{ Exporter };
 	@EXPORT    = qw{ home     };
 	@EXPORT_OK = qw{
 		home
 		my_home
 		my_desktop
 		my_documents
 		my_music
 		my_pictures
 		my_videos
 		my_data
 		my_dist_config
 		my_dist_data
 		users_home
 		users_desktop
 		users_documents
 		users_music
 		users_pictures
 		users_videos
 		users_data
 	};
 
 }
 
 sub _CLASS ($) {
 	(defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s) ? $_[0] : undef;
 }
 sub _DRIVER ($$) {
 	(defined _CLASS($_[0]) and eval "require $_[0];" and ! $@ and $_[0]->isa($_[1]) and $_[0] ne $_[1]) ? $_[0] : undef;
 }
 
 if ( $IMPLEMENTED_BY ) {
 } elsif ( $^O eq 'MSWin32' ) {
 	$IMPLEMENTED_BY = 'File::HomeDir::Windows';
 } elsif ( $^O eq 'darwin') {
 	if ( eval { require Mac::SystemDirectory; 1 } ) {
 		$IMPLEMENTED_BY = 'File::HomeDir::Darwin::Cocoa';
 	} elsif ( eval { require Mac::Files; 1 } ) {
 		$IMPLEMENTED_BY = 'File::HomeDir::Darwin::Carbon';
 	} else {
 		$IMPLEMENTED_BY = 'File::HomeDir::Darwin';
 	}
 } elsif ( $^O eq 'MacOS' ) {
 	$IMPLEMENTED_BY = 'File::HomeDir::MacOS9';
 } elsif ( File::Which::which('xdg-user-dir') ) {
 	$IMPLEMENTED_BY = 'File::HomeDir::FreeDesktop';
 } else {
 	$IMPLEMENTED_BY = 'File::HomeDir::Unix';
 }
 unless ( _DRIVER($IMPLEMENTED_BY, 'File::HomeDir::Driver') ) {
 	Carp::croak("Missing or invalid File::HomeDir driver $IMPLEMENTED_BY");
 }
 
 
 
 
 
 
 sub my_home {
 	$IMPLEMENTED_BY->my_home;
 }
 
 sub my_desktop {
 	$IMPLEMENTED_BY->can('my_desktop')
 		? $IMPLEMENTED_BY->my_desktop
 		: Carp::croak("The my_desktop method is not implemented on this platform");
 }
 
 sub my_documents {
 	$IMPLEMENTED_BY->can('my_documents')
 		? $IMPLEMENTED_BY->my_documents
 		: Carp::croak("The my_documents method is not implemented on this platform");
 }
 
 sub my_music {
 	$IMPLEMENTED_BY->can('my_music')
 		? $IMPLEMENTED_BY->my_music
 		: Carp::croak("The my_music method is not implemented on this platform");
 }
 
 sub my_pictures {
 	$IMPLEMENTED_BY->can('my_pictures')
 		? $IMPLEMENTED_BY->my_pictures
 		: Carp::croak("The my_pictures method is not implemented on this platform");
 }
 
 sub my_videos {
 	$IMPLEMENTED_BY->can('my_videos')
 		? $IMPLEMENTED_BY->my_videos
 		: Carp::croak("The my_videos method is not implemented on this platform");
 }
 
 sub my_data {
 	$IMPLEMENTED_BY->can('my_data')
 		? $IMPLEMENTED_BY->my_data
 		: Carp::croak("The my_data method is not implemented on this platform");
 }
 
 
 sub my_dist_data {
 	my $params = ref $_[-1] eq 'HASH' ? pop : {};
 	my $dist   = pop or Carp::croak("The my_dist_data method requires an argument");
 	my $data   = my_data();
 
 	return undef unless defined $data;
 
 	my $var = $data eq home()
 		? File::Spec->catdir( $data, '.perl', 'dist', $dist )
 		: File::Spec->catdir( $data, 'Perl',  'dist', $dist );
 
 	return $var if -d $var;
 
 	return undef unless $params->{create};
 
 	require File::Path;
 	File::Path::mkpath( $var );
 	return $var;
 }
 
 sub my_dist_config {
 	my $params = ref $_[-1] eq 'HASH' ? pop : {};
 	my $dist   = pop or Carp::croak("The my_dist_config method requires an argument");
 
 	my $config = $IMPLEMENTED_BY->can('my_config')
 		? $IMPLEMENTED_BY->my_config
 		: $IMPLEMENTED_BY->my_documents;
 
 	return undef unless defined $config;
 
 	my $etc = $config eq home()
 		? File::Spec->catdir( $config, '.perl', $dist )
 		: File::Spec->catdir( $config, 'Perl',  $dist );
 
 	return $etc if -d $etc;
 
 	return undef unless $params->{create};
 
 	require File::Path;
 	File::Path::mkpath( $etc );
 	return $etc;
 }
 
 
 
 
 
 sub users_home {
 	$IMPLEMENTED_BY->can('users_home')
 		? $IMPLEMENTED_BY->users_home( $_[-1] )
 		: Carp::croak("The users_home method is not implemented on this platform");
 }
 
 sub users_desktop {
 	$IMPLEMENTED_BY->can('users_desktop')
 		? $IMPLEMENTED_BY->users_desktop( $_[-1] )
 		: Carp::croak("The users_desktop method is not implemented on this platform");
 }
 
 sub users_documents {
 	$IMPLEMENTED_BY->can('users_documents')
 		? $IMPLEMENTED_BY->users_documents( $_[-1] )
 		: Carp::croak("The users_documents method is not implemented on this platform");
 }
 
 sub users_music {
 	$IMPLEMENTED_BY->can('users_music')
 		? $IMPLEMENTED_BY->users_music( $_[-1] )
 		: Carp::croak("The users_music method is not implemented on this platform");
 }
 
 sub users_pictures {
 	$IMPLEMENTED_BY->can('users_pictures')
 		? $IMPLEMENTED_BY->users_pictures( $_[-1] )
 		: Carp::croak("The users_pictures method is not implemented on this platform");
 }
 
 sub users_videos {
 	$IMPLEMENTED_BY->can('users_videos')
 		? $IMPLEMENTED_BY->users_videos( $_[-1] )
 		: Carp::croak("The users_videos method is not implemented on this platform");
 }
 
 sub users_data {
 	$IMPLEMENTED_BY->can('users_data')
 		? $IMPLEMENTED_BY->users_data( $_[-1] )
 		: Carp::croak("The users_data method is not implemented on this platform");
 }
 
 
 
 
 
 
 sub home (;$) {
 	if ( $_[0] and $_[0] eq 'File::HomeDir' ) {
 		shift();
 	}
 
 	return my_home() unless @_;
 
 	my $name = shift;
 	if ( ! defined $name ) {
 		Carp::croak("Can't use undef as a username");
 	}
 	if ( ! length $name ) {
 		Carp::croak("Can't use empty-string (\"\") as a username");
 	}
 
 	if ( $name eq '.' ) {
 		return my_home();
 	}
 
 	$IMPLEMENTED_BY->users_home($name);
 }
 
 
 
 
 
 
 
 CLASS: {
 	package File::HomeDir::TIE;
 
 	my $SINGLETON = bless {};
 
 	sub TIEHASH { $SINGLETON }
 
 	sub FETCH {
 		unless ( defined $_[1] ) {
 			Carp::croak("Can't use undef as a username");
 		}
 
 		unless ( length $_[1] ) {
 			return File::HomeDir::my_home();
 		}
 
 		Carp::carp("The tied %~ hash has been deprecated");
 		return File::HomeDir::home($_[1]);
 	}
 
 	sub STORE    { _bad('STORE')    }
 	sub EXISTS   { _bad('EXISTS')   }
 	sub DELETE   { _bad('DELETE')   }
 	sub CLEAR    { _bad('CLEAR')    }
 	sub FIRSTKEY { _bad('FIRSTKEY') }
 	sub NEXTKEY  { _bad('NEXTKEY')  }
 
 	sub _bad ($) {
 		Carp::croak("You can't $_[0] with the %~ hash")
 	}
 }
 
 tie %~, 'File::HomeDir::TIE';
 
 1;
 
 __END__
 
### File/HomeDir/Darwin.pm ###
 package File::HomeDir::Darwin;
 
 use 5.00503;
 use strict;
 use Cwd                 ();
 use Carp                ();
 use File::HomeDir::Unix ();
 
 use vars qw{$VERSION @ISA};
 BEGIN {
 	$VERSION = '1.00';
 	@ISA     = 'File::HomeDir::Unix';
 }
 
 
 
 
 
 
 sub my_home {
 	my $class = shift;
 
 	if ( exists $ENV{HOME} and defined $ENV{HOME} ) {
 		return $ENV{HOME};
 	}
 
 	my $home = (getpwuid($<))[7];
 	return $home if $home && -d $home;
 
 	return undef;
 }
 
 sub _my_home {
 	my($class, $path) = @_;
 	my $home = $class->my_home;
 	return undef unless defined $home;
 
 	my $folder = "$home/$path";
 	unless ( -d $folder ) {
 		return undef unless -l $folder;
 		my $dir = readlink $folder or return;
 		return undef unless -d $dir;
 	}
 
 	return Cwd::abs_path($folder);
 }
 
 sub my_desktop {
 	my $class = shift;
 	$class->_my_home('Desktop');
 }
 
 sub my_documents {
 	my $class = shift;
 	$class->_my_home('Documents');
 }
 
 sub my_data {
 	my $class = shift;
 	$class->_my_home('Library/Application Support');
 }
 
 sub my_music {
 	my $class = shift;
 	$class->_my_home('Music');
 }
 
 sub my_pictures {
 	my $class = shift;
 	$class->_my_home('Pictures');
 }
 
 sub my_videos {
 	my $class = shift;
 	$class->_my_home('Movies');
 }
 
 
 
 
 
 
 sub users_home {
 	my $class = shift;
 	my $home  = $class->SUPER::users_home(@_);
 	return defined $home ? Cwd::abs_path($home) : undef;
 }
 
 sub users_desktop {
 	my ($class, $name) = @_;
 	return undef if $name eq 'root';
 	$class->_to_user( $class->my_desktop, $name );
 }
 
 sub users_documents {
 	my ($class, $name) = @_;
 	return undef if $name eq 'root';
 	$class->_to_user( $class->my_documents, $name );
 }
 
 sub users_data {
 	my ($class, $name) = @_;
 	$class->_to_user( $class->my_data, $name )
 	||
 	$class->users_home($name);
 }
 
 sub _to_user {
 	my ($class, $path, $name) = @_;
 	my $my_home    = $class->my_home;
 	my $users_home = $class->users_home($name);
 	defined $users_home or return undef;
 	$path =~ s/^\Q$my_home/$users_home/;
 	return $path;
 }
 
 1;
 
### File/HomeDir/Darwin/Carbon.pm ###
 package File::HomeDir::Darwin::Carbon;
 
 
 use 5.00503;
 use strict;
 use Cwd                   ();
 use Carp                  ();
 use File::HomeDir::Darwin ();
 
 use vars qw{$VERSION @ISA};
 BEGIN {
 	$VERSION = '1.00';
 
 	@ISA = 'File::HomeDir::Darwin';
 
 	local $@;
 	eval "use prefork 'Mac::Files'";
 }
 
 
 
 
 
 
 sub my_home {
 	my $class = shift;
 
 	if ( exists $ENV{HOME} and defined $ENV{HOME} ) {
 		return $ENV{HOME};
 	}
 
 	require Mac::Files;
 	$class->_find_folder(
 		Mac::Files::kCurrentUserFolderType(),
 	);
 }
 
 sub my_desktop {
 	my $class = shift;
 
 	require Mac::Files;
 	$class->_find_folder(
 		Mac::Files::kDesktopFolderType(),
 	);
 }
 
 sub my_documents {
 	my $class = shift;
 
 	require Mac::Files;
 	$class->_find_folder(
 		Mac::Files::kDocumentsFolderType(),
 	);
 }
 
 sub my_data {
 	my $class = shift;
 
 	require Mac::Files;
 	$class->_find_folder(
 		Mac::Files::kApplicationSupportFolderType(),
 	);
 }
 
 sub my_music {
 	my $class = shift;
 
 	require Mac::Files;
 	$class->_find_folder(
 		Mac::Files::kMusicDocumentsFolderType(),
 	);
 }
 
 sub my_pictures {
 	my $class = shift;
 
 	require Mac::Files;
 	$class->_find_folder(
 		Mac::Files::kPictureDocumentsFolderType(),
 	);
 }
 
 sub my_videos {
 	my $class = shift;
 
 	require Mac::Files;
 	$class->_find_folder(
 		Mac::Files::kMovieDocumentsFolderType(),
 	);
 }
 
 sub _find_folder {
 	my $class = shift;
 	my $name  = shift;
 
 	require Mac::Files;
 	my $folder = Mac::Files::FindFolder(
 		Mac::Files::kUserDomain(),
 		$name,
 	);
 	return undef unless defined $folder;
 
 	unless ( -d $folder ) {
 		return undef unless -l $folder;
 		my $dir = readlink $folder or return;
 		return undef unless -d $dir;
 	}
 
 	return Cwd::abs_path($folder);
 }
 
 
 
 
 
 
 sub users_home {
 	my $class = shift;
 	my $home  = $class->SUPER::users_home(@_);
 	return defined $home ? Cwd::abs_path($home) : undef;
 }
 
 sub users_desktop {
 	my ($class, $name) = @_;
 	return undef if $name eq 'root';
 	$class->_to_user( $class->my_desktop, $name );
 }
 
 sub users_documents {
 	my ($class, $name) = @_;
 	return undef if $name eq 'root';
 	$class->_to_user( $class->my_documents, $name );
 }
 
 sub users_data {
 	my ($class, $name) = @_;
 	$class->_to_user( $class->my_data, $name )
 	||
 	$class->users_home($name);
 }
 
 sub _to_user {
 	my ($class, $path, $name) = @_;
 	my $my_home    = $class->my_home;
 	my $users_home = $class->users_home($name);
 	defined $users_home or return undef;
 	$path =~ s/^\Q$my_home/$users_home/;
 	return $path;
 }
 
 1;
 
### File/HomeDir/Darwin/Cocoa.pm ###
 package File::HomeDir::Darwin::Cocoa;
 
 use 5.00503;
 use strict;
 use Cwd                   ();
 use Carp                  ();
 use File::HomeDir::Darwin ();
 
 use vars qw{$VERSION @ISA};
 BEGIN {
 	$VERSION = '1.00';
 	@ISA     = 'File::HomeDir::Darwin';
 
 	local $@;
 	eval "use prefork 'Mac::SystemDirectory'";
 }
 
 
 
 
 
 
 sub my_home {
 	my $class = shift;
 
 	if ( exists $ENV{HOME} and defined $ENV{HOME} ) {
 		return $ENV{HOME};
 	}
 
 	require Mac::SystemDirectory;
 	return Mac::SystemDirectory::HomeDirectory();
 }
 
 sub my_desktop {
 	my $class = shift;
 
 	require Mac::SystemDirectory;
 	eval {
 		$class->_find_folder(Mac::SystemDirectory::NSDesktopDirectory())
 	}
 	||
 	$class->SUPER::my_desktop;
 }
 
 sub my_documents {
 	my $class = shift;
 
 	require Mac::SystemDirectory;
 	eval {
 		$class->_find_folder(Mac::SystemDirectory::NSDocumentDirectory())
 	}
 	||
 	$class->SUPER::my_documents;
 }
 
 sub my_data {
 	my $class = shift;
 
 	require Mac::SystemDirectory;
 	eval {
 		$class->_find_folder(Mac::SystemDirectory::NSApplicationSupportDirectory())
 	}
 	||
 	$class->SUPER::my_data;
 }
 
 sub my_music {
 	my $class = shift;
 
 	require Mac::SystemDirectory;
 	eval {
 		$class->_find_folder(Mac::SystemDirectory::NSMusicDirectory())
 	}
 	||
 	$class->SUPER::my_music;
 }
 
 sub my_pictures {
 	my $class = shift;
 
 	require Mac::SystemDirectory;
 	eval {
 		$class->_find_folder(Mac::SystemDirectory::NSPicturesDirectory())
 	}
 	||
 	$class->SUPER::my_pictures;
 }
 
 sub my_videos {
 	my $class = shift;
 
 	require Mac::SystemDirectory;
 	eval {
 		$class->_find_folder(Mac::SystemDirectory::NSMoviesDirectory())
 	}
 	||
 	$class->SUPER::my_videos;
 }
 
 sub _find_folder {
 	my $class = shift;
 	my $name  = shift;
 
 	require Mac::SystemDirectory;
 	my $folder = Mac::SystemDirectory::FindDirectory($name);
 	return undef unless defined $folder;
 
 	unless ( -d $folder ) {
 		return undef unless -l $folder;
 		my $dir = readlink $folder or return;
 		return undef unless -d $dir;
 	}
 
 	return Cwd::abs_path($folder);
 }
 
 1;
 
### File/HomeDir/Driver.pm ###
 package File::HomeDir::Driver;
 
 
 use 5.00503;
 use strict;
 use Carp ();
 
 use vars qw{$VERSION};
 BEGIN {
 	$VERSION = '1.00';
 }
 
 sub my_home {
 	Carp::croak("$_[0] does not implement compulsory method $_[1]");
 }
 
 1;
 
### File/HomeDir/FreeDesktop.pm ###
 package File::HomeDir::FreeDesktop;
 
 
 
 use 5.00503;
 use strict;
 use Carp                ();
 use File::Spec          ();
 use File::Which         ();
 use File::HomeDir::Unix ();
 
 use vars qw{$VERSION @ISA};
 BEGIN {
 	$VERSION = '1.00';
 	@ISA     = 'File::HomeDir::Unix';
 }
 
 
 my $xdgprog = File::Which::which('xdg-user-dir');
 
 sub _my {
 	my $thingy = qx($xdgprog $_[1]);
 	chomp $thingy;
 	return $thingy;
 }
 
 sub my_desktop   { shift->_my('DESKTOP')   }
 sub my_documents { shift->_my('DOCUMENTS') }
 sub my_music     { shift->_my('MUSIC')     }
 sub my_pictures  { shift->_my('PICTURES')  }
 sub my_videos    { shift->_my('VIDEOS')    }
 
 sub my_data {
 	$ENV{XDG_DATA_HOME}
 	or
 	File::Spec->catdir(
 		shift->my_home,
 		qw{ .local share }
 	);
 }
 
 sub my_config {
 	$ENV{XDG_CONFIG_HOME}
 	or
 	File::Spec->catdir(
 		shift->my_home,
 		qw{ .config }
 	);
 }
 
 sub my_download    { shift->_my('DOWNLOAD')    }
 sub my_publicshare { shift->_my('PUBLICSHARE') }
 sub my_templates   { shift->_my('TEMPLATES')   }
 
 sub my_cache {
     $ENV{XDG_CACHE_HOME}
     ||
     File::Spec->catdir(shift->my_home, qw{ .cache });
 }
 
 
 
 
 
 
 sub users_desktop   { Carp::croak('The users_desktop method is not available on an XDG based system.');   }
 sub users_documents { Carp::croak('The users_documents method is not available on an XDG based system.'); }
 sub users_music     { Carp::croak('The users_music method is not available on an XDG based system.');     }
 sub users_pictures  { Carp::croak('The users_pictures method is not available on an XDG based system.');  }
 sub users_videos    { Carp::croak('The users_videos method is not available on an XDG based system.');    }
 sub users_data      { Carp::croak('The users_data method is not available on an XDG based system.');      }
 
 1;
 
### File/HomeDir/MacOS9.pm ###
 package File::HomeDir::MacOS9;
 
 
 use 5.00503;
 use strict;
 use Carp                  ();
 use File::HomeDir::Driver ();
 
 use vars qw{$VERSION @ISA};
 BEGIN {
 	$VERSION = '1.00';
 	@ISA     = 'File::HomeDir::Driver';
 }
 
 SCOPE: {
 	local $@;
 	eval "use prefork 'Mac::Files'";
 }
 
 
 
 
 
 
 sub my_home {
 	my $class = shift;
 
 	if ( defined $ENV{HOME} ) {
 		return $ENV{HOME};
 	}
 
 
 	SCOPE: {
 		local $@;
 		eval {
 			my $home = $class->my_desktop;
 			return $home if $home and -d $home;
 		};
 	}
 
 	SCOPE: {
 		local $SIG{'__DIE__'} = '';
 		my $home = (getpwuid($<))[7];
 		return $home if $home and -d $home;
 	}
 
 	Carp::croak("Could not locate current user's home directory");
 }
 
 sub my_desktop {
 	my $class = shift;
 
 	local $SIG{'__DIE__'} = '';
 	require Mac::Files;
 	my $home = Mac::Files::FindFolder(
 		Mac::Files::kOnSystemDisk(),
 		Mac::Files::kDesktopFolderType(),
 		);
 	return $home if $home and -d $home;
 
 	Carp::croak("Could not locate current user's desktop");
 }
 
 
 
 
 
 
 sub users_home {
 	my ($class, $name) = @_;
 
 	SCOPE: {
 		local $SIG{'__DIE__'} = '';
 		my $home = (getpwnam($name))[7];
 		return $home if defined $home and -d $home;
 	}
 
 	Carp::croak("Failed to find home directory for user '$name'");
 }
 
 1;
 
### File/HomeDir/Test.pm ###
 package File::HomeDir::Test;
 
 use 5.00503;
 use strict;
 use Carp                  ();
 use File::Spec            ();
 use File::Temp            ();
 use File::HomeDir::Driver ();
 
 use vars qw{$VERSION @ISA %DIR $ENABLED};
 BEGIN {
 	$VERSION = '1.00';
 	@ISA     = 'File::HomeDir::Driver';
 	%DIR     = ();
 	$ENABLED = 0;
 }
 
 sub import {
 	my $class = shift;
 	die "Attempted to initialise File::HomeDir::Test trice" if %DIR;
 
 	my $BASE  = File::Temp::tempdir( CLEANUP => 1 );
 	%DIR = map { $_ => File::Spec->catdir( $BASE, $_ ) } qw{
 		my_home
 		my_desktop
 		my_documents
 		my_data
 		my_music
 		my_pictures
 		my_videos
 	};
 
 	$ENV{HOME} = $DIR{my_home};
 
 	$File::HomeDir::IMPLEMENTED_BY = 
 	$File::HomeDir::IMPLEMENTED_BY = 'File::HomeDir::Test';
 
 	$ENABLED = 1;
 }
 
 
 
 
 
 
 sub my_home {
 	mkdir($DIR{my_home}, 0755) unless -d $DIR{my_home};
 	return $DIR{my_home};
 }
 
 sub my_desktop {
 	mkdir($DIR{my_desktop}, 0755) unless -d $DIR{my_desktop};
 	return $DIR{my_desktop};
 }
 
 sub my_documents {
 	mkdir($DIR{my_documents}, 0755) unless -f $DIR{my_documents};
 	return $DIR{my_documents};
 }
 
 sub my_data {
 	mkdir($DIR{my_data}, 0755) unless -d $DIR{my_data};
 	return $DIR{my_data};
 }
 
 sub my_music {
 	mkdir($DIR{my_music}, 0755) unless -d $DIR{my_music};
 	return $DIR{my_music};
 }
 
 sub my_pictures {
 	mkdir($DIR{my_pictures}, 0755) unless -d $DIR{my_pictures};
 	return $DIR{my_pictures};
 }
 
 sub my_videos {
 	mkdir($DIR{my_videos}, 0755) unless -d $DIR{my_videos};
 	return $DIR{my_videos};
 }
 
 sub users_home {
 	return undef;
 }
 
 1;
 
 __END__
 
### File/HomeDir/Unix.pm ###
 package File::HomeDir::Unix;
 
 
 use 5.00503;
 use strict;
 use Carp                  ();
 use File::HomeDir::Driver ();
 
 use vars qw{$VERSION @ISA};
 BEGIN {
 	$VERSION = '1.00';
 	@ISA     = 'File::HomeDir::Driver';
 }
 
 
 
 
 
 
 sub my_home {
 	my $class = shift;
 	my $home  = $class->_my_home(@_);
 
 	if ( defined $home and ! -d $home ) {
 		$home = undef;
 	}
 
 	return $home;
 }
 
 sub _my_home {
 	my $class = shift;
 	if ( exists $ENV{HOME} and defined $ENV{HOME} ) {
 		return $ENV{HOME};
 	}
 
 	if ( exists $ENV{LOGDIR} and $ENV{LOGDIR} ) {
 		return $ENV{LOGDIR};
 	}
 
 
 	SCOPE: {
 		my $home = (getpwuid($<))[7];
 		return $home if $home and -d $home;
 	}
 
 	return undef;
 }
 
 sub my_desktop {
 	shift->my_home;
 }
 
 sub my_documents {
 	shift->my_home;
 }
 
 sub my_data {
 	shift->my_home;
 }
 
 sub my_music {
 	shift->my_home;
 }
 
 sub my_pictures {
 	shift->my_home;
 }
 
 sub my_videos {
 	shift->my_home;
 }
 
 
 
 
 
 
 sub users_home {
 	my ($class, $name) = @_;
 
 	if ( $name eq getpwuid($<) ) {
 		return $class->my_home;
 	}
 
 	SCOPE: {
 		my $home = (getpwnam($name))[7];
 		return $home if $home and -d $home;
 	}
 
 	return undef;
 }
 
 sub users_desktop {
 	shift->users_home(@_);
 }
 
 sub users_documents {
 	shift->users_home(@_);
 }
 
 sub users_data {
 	shift->users_home(@_);
 }
 
 sub users_music {
 	shift->users_home(@_);
 }
 
 sub users_pictures {
 	shift->users_home(@_);
 }
 
 sub users_videos {
 	shift->users_home(@_);
 }
 
 1;
 
### File/HomeDir/Windows.pm ###
 package File::HomeDir::Windows;
 
 
 use 5.00503;
 use strict;
 use Carp                  ();
 use File::Spec            ();
 use File::HomeDir::Driver ();
 
 use vars qw{$VERSION @ISA};
 BEGIN {
 	$VERSION = '1.00';
 	@ISA     = 'File::HomeDir::Driver';
 }
 
 sub CREATE () { 1 }
 
 
 
 
 
 
 sub my_home {
 	my $class = shift;
 
 	if ( exists $ENV{HOME} and $ENV{HOME} ) {
 		return $ENV{HOME};
 	}
 
 	if ( exists $ENV{USERPROFILE} and $ENV{USERPROFILE} ) {
 		return $ENV{USERPROFILE};
 	}
 
 	if ( exists $ENV{HOMEDRIVE} and exists $ENV{HOMEPATH} and $ENV{HOMEDRIVE} and $ENV{HOMEPATH} ) {
 		return File::Spec->catpath(
 			$ENV{HOMEDRIVE}, $ENV{HOMEPATH}, '',
 		);
 	}
 
 	return undef;
 }
 
 sub my_desktop {
 	my $class = shift;
 
 	SCOPE: {
 		require Win32;
 		my $dir = Win32::GetFolderPath(Win32::CSIDL_DESKTOP(), CREATE);
 		return $dir if $dir and $class->_d($dir);
 	}
 
 	foreach my $e ( 'USERPROFILE', 'WINDIR' ) {
 		next unless $ENV{$e};
 		my $desktop = File::Spec->catdir($ENV{$e}, 'Desktop');
 		return $desktop if $desktop and $class->_d($desktop);
 	}
 
 	foreach my $fixed (
 		"C:\\windows\\desktop",
 		"C:\\win95\\desktop",
 		"C:/win95/desktop",
 		"C:/windows/desktop",
 	) {
 		return $fixed if $class->_d($fixed);
 	}
 
 	return undef;
 }
 
 sub my_documents {
 	my $class = shift;
 
 	SCOPE: {
 		require Win32;
 		my $dir = Win32::GetFolderPath(Win32::CSIDL_PERSONAL(), CREATE);
 		return $dir if $dir and $class->_d($dir);
 	}
 
 	return undef;
 }
 
 sub my_data {
 	my $class = shift;
 
 	SCOPE: {
 		require Win32;
 		my $dir = Win32::GetFolderPath(Win32::CSIDL_LOCAL_APPDATA(), CREATE);
 		return $dir if $dir and $class->_d($dir);
 	}
 
 	return undef;
 }
 
 sub my_music {
 	my $class = shift;
 
 	SCOPE: {
 		require Win32;
 		my $dir = Win32::GetFolderPath(Win32::CSIDL_MYMUSIC(), CREATE);
 		return $dir if $dir and $class->_d($dir);
 	}
 
 	return undef;
 }
 
 sub my_pictures {
 	my $class = shift;
 
 	SCOPE: {
 		require Win32;
 		my $dir = Win32::GetFolderPath(Win32::CSIDL_MYPICTURES(), CREATE);
 		return $dir if $dir and $class->_d($dir);
 	}
 
 	return undef;
 }
 
 sub my_videos {
 	my $class = shift;
 
 	SCOPE: {
 		require Win32;
 		my $dir = Win32::GetFolderPath(Win32::CSIDL_MYVIDEO(), CREATE);
 		return $dir if $dir and $class->_d($dir);
 	}
 
 	return undef;
 }
 
 sub _d {
 	my $self = shift;
 	my $path = shift;
 
 	if ( $path =~ /\\\\/ ) {
 		return 1;
 	}
 
 	return -d $path;
 }
 
 1;
 
### File/RsyBak.pm ###
 package File::RsyBak;
 
 our $DATE = '2015-10-22'; 
 our $VERSION = '0.29'; 
 
 use 5.010001;
 use strict;
 use warnings;
 use Log::Any::IfLOG '$log';
 
 use File::chdir;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(backup);
 
 our %SPEC;
 
 sub _parse_path {
     require Cwd;
 
     my ($path) = @_;
     $path =~ s!/+$!!;
     if ($path =~ m!^(\S+)::([^/]+)/?(.*)$!) {
         return {
             raw=>$path, remote=>1, host=>$1,
             proto=>"rsync", module=>$2, path=>$3,
         };
     } elsif ($path =~ m!([^@]+)?\@?(^\S+):(.*)$!) {
         return {
             raw=>$path, remote=>1, host=>$2,
             user=>$1, proto=>"ssh", path=>$3,
         };
     } else {
         return {
             raw=>$path, remote=>0, path=>$path,
             abs_path=>Cwd::abs_path($path)
         };
     }
 }
 
 sub _check_sources {
     my ($sources) = @_;
 
     my $all_local = 1;
     for (@$sources) {
         if ($_->{remote}) { $all_local = 0; last }
     }
 
     my $all_remote = 1;
     for (@$sources) {
         if (!$_->{remote}) { $all_remote = 0; last }
     }
 
     return [400, "Sources must be all local or all remote"]
         unless $all_remote || $all_local;
 
     if ($all_remote) {
         my $host;
         for (@$sources) {
             $host //= $_->{host};
             return [400, "Remote sources must all be from the same machine"]
                 if $host ne $_->{host};
         }
     }
     [200, "OK"];
 }
 
 $SPEC{backup} = {
     v             => 1.1,
     summary       =>
         'Backup files/directories with histories, using rsync',
     args          => {
         source           => {
             summary      => 'Director(y|ies) to backup',
             schema       => 'str*', 
             req          => 1,
             pos          => 0,
         },
         target           => {
             summary      => 'Backup destination',
             schema       => ['str*'   => {}],
             req          => 1,
             pos          => 1,
         },
         histories        => {
             summary      => 'Histories/history levels',
             schema       => ['array' => {
                 default      => [-7, 4, 3],
                 of           => 'int*',
             }],
             description  => <<'_',
 
 Specifies number of backup histories to keep for level 1, 2, and so on. If
 number is negative, specifies number of days to keep instead (regardless of
 number of histories).
 
 _
         },
         extra_dir        => {
             summary      =>
                 'Whether to force creation of source directory in target',
             schema       => ['bool'   => {}],
             description  => <<'_',
 
 If set to 1, then backup(source => '/a', target => '/backup/a') will create
 another 'a' directory in target, i.e. /backup/a/current/a. Otherwise, contents
 of a/ will be directly copied under /backup/a/current/.
 
 Will always be set to 1 if source is more than one, but default to 0 if source
 is a single directory. You can set this to 1 to so that behaviour when there is
 a single source is the same as behaviour when there are several sources.
 
 _
         },
         backup           => {
             summary      => 'Whether to do backup or not',
             schema       => [bool     => {
                 default      => 1,
             }],
             description  => <<'_',
 
 If backup=1 and rotate=0 then will only create new backup without rotating
 histories.
 
 _
         },
         rotate           => {
             summary      => 'Whether to do rotate after backup or not',
             schema       => [bool     => {
                 default      => 1,
             }],
             description  => <<'_',
 
 If backup=0 and rotate=1 then will only do history rotating.
 
 _
         },
         extra_rsync_opts => {
             summary      => 'Pass extra options to rsync command',
             schema       => [array    => {
                 of           => 'str*',
             }],
             description  => <<'_',
 
 Extra options to pass to rsync command when doing backup. Note that the options
 will be shell quoted, , so you should pass it unquoted, e.g. ['--exclude',
 '/Program Files'].
 
 _
         },
     },
 
     examples => [
         {
             argv         => ['/home/jajang/mydata','/backup/jajang/mydata'],
             test         => 0,
             description  => <<'_',
 
 Backup /home/jajang/mydata to /backup/jajang/mydata using the default number of
 histories ([-7, 4, 3]).
 
 _
         },
     ],
 
     deps => {
         all => [
             {prog => 'nice'},
             {prog => 'rsync'}, 
             {prog => 'rm'},    
         ],
     },
 };
 sub backup {
     require File::Flock::Retry;
     require File::Path;
     require File::Which;
 
     my %args = @_;
 
     my $source    = $args{source} or return [400, "Please specify source"];
     my @sources   = ref($source) eq 'ARRAY' ? @$source : ($source);
     for (@sources) { $_ = _parse_path($_) }
     my $res = _check_sources(\@sources);
     return $res unless $res->[0] == 200;
     my $target    = $args{target} or return [400, "Please specify target"];
     $target       = _parse_path($target);
     $target->{remote} and
         return [400, "Sorry, target can't be remote at the moment"];
     my $histories = $args{histories} // [-7, 4, 3];
     ref($histories) eq 'ARRAY' or return [400, "histories must be array"];
     my $backup    = $args{backup} // 1;
     my $rotate    = $args{rotate} // 1;
     my $extra_dir = $args{extra_dir} || (@sources > 1);
 
     my $rsync_path = File::Which::which("rsync")
         or return [500, "Can't find rsync in PATH"];
 
     unless (-d $target->{abs_path}) {
         $log->debugf("Creating target directory %s ...", $target->{abs_path});
         File::Path::make_path($target->{abs_path})
             or return [500, "Error: Can't create target directory ".
                 "$target->{abs_path}: $!"];
     }
 
     my $lock = File::Flock::Retry->lock("$target->{abs_path}/.lock");
 
     if ($backup) {
         _backup(
             \@sources, $target,
             {
                 extra_dir        => $extra_dir,
                 extra_rsync_opts => $args{extra_rsync_opts},
             });
     }
 
     if ($rotate) {
         _rotate($target->{abs_path}, $histories);
     }
 
     [200, "OK"];
 }
 
 sub _backup {
     require POSIX;
     require String::ShellQuote; String::ShellQuote->import;
 
     my ($sources, $target, $opts) = @_;
     $log->infof("Starting backup %s ==> %s ...",
                 [map {$_->{raw}} @$sources], $target);
     my $cmd;
     $cmd = join(
         "",
         "nice -n19 rsync ",
         ($opts->{extra_rsync_opts} ? map { shell_quote($_), " " }
              @{$opts->{extra_rsync_opts}} : ()),
         "-a --del --force --ignore-errors --ignore-existing ",
         ((-e "$target->{abs_path}/current") ?
              "--link-dest ".shell_quote("$target->{abs_path}/current")." "
                  : ""),
         map({ shell_quote($_->{raw}), ($opts->{extra_dir} ? "" : "/"), " " }
                 @$sources),
         shell_quote("$target->{abs_path}/.tmp/"),
     );
     $log->debug("Running rsync ...");
     $log->trace("system(): $cmd");
     system $cmd;
     $log->warn("rsync didn't succeed ($?)".
                    ", please recheck") if $?;
 
 
     if (-e "$target->{abs_path}/current") {
         my $tspath = "$target->{abs_path}/.current.timestamp";
         my @st     = stat($tspath);
         my $tstamp = POSIX::strftime(
             "%Y-%m-%d\@%H:%M:%S+00",
             gmtime( $st[9] || time() )); 
         $log->debug("rename $target->{abs_path}/current ==> ".
                         "hist.$tstamp ...");
         unless (rename "$target->{abs_path}/current",
                 "$target->{abs_path}/hist.$tstamp") {
             $log->warn("Failed renaming $target->{abs_path}/current ==> ".
                          "hist.$tstamp: $!");
         }
         $log->debug("touch $tspath ...");
         system "touch ".shell_quote($tspath);
     }
 
     $log->debug("rename $target->{abs_path}/.tmp ==> current ...");
     unless (rename "$target->{abs_path}/.tmp",
             "$target->{abs_path}/current") {
         $log->warn("Failed renaming $target->{abs_path}/.tmp ==> current: $!");
     }
 
     $log->infof("Finished backup %s ==> %s", $sources, $target);
 }
 
 sub _rotate {
     require String::ShellQuote; String::ShellQuote->import;
     require Time::Local;
 
     my ($target, $histories) = @_;
     $log->infof("Rotating backup histories in %s (%s) ...",
                 $target, $histories);
 
     local $CWD = $target; 
 
     my $now = time();
     for my $level (1 .. @$histories) {
         my $is_highest_level  = $level == @$histories;
         my $prefix            = "hist" . ($level == 1 ? '' : $level);
         my $prefix_next_level = "hist" . ($level + 1);
         my $n                 = $histories->[$level - 1];
         my $moved             = 0;
 
         if ($n > 0) {
             $log->debug("Only keeping $n level-$level histories ...");
             my @f = reverse sort grep { !/\.tmp$/ } glob "$prefix.*";
             my $any_tagged = (grep {/t$/} @f) ? 1 : 0;
             for my $f (@f[ $n .. @f - 1 ]) {
                 my ($st, $tagged) = $f =~ /[^.]+\.(.+?)(t)?$/;
                 my $f2 = "$prefix_next_level.$st";
                 if (!$is_highest_level &&
                         !$moved && ($tagged || !$any_tagged)) {
                     $log->debug("Moving history level: $f -> $f2");
                     rename $f, $f2;
                     $moved++;
                     if ($f ne $f[0]) {
                         rename $f[0], "$f[0]t";
                     }
                 } else {
                     $log->debug("Removing history: $f ...");
                     system "nice -n19 rm -rf " . shell_quote($f);
                 }
             }
         } else {
             $n = -$n;
             $log->debug("Only keeping $n day(s) of level-$level histories ...");
             my @f = reverse sort grep { !/\.tmp$/ } glob "$prefix.*";
             my $any_tagged = ( grep {/t$/} @f ) ? 1 : 0;
             for my $f (@f) {
                 my ($st, $tagged) = $f =~ /[^.]+\.(.+?)(t)?$/;
                 my $f2 = "$prefix_next_level.$st";
                 my $t;
                 $st =~ /(\d\d\d\d)-(\d\d)-(\d\d)\@(\d\d):(\d\d):(\d\d)\+00/;
                 $t = Time::Local::timegm($6, $5, $4, $3, $2 - 1, $1) if $1;
                 unless ($st && $t) {
                     $log->warn("Wrong format of history, ignored: $f");
                     next;
                 }
                 if ($t > $now) {
                     $log->warn("History in the future, ignored: $f");
                     next;
                 }
                 my $delta = ($now - $t) / 86400;
                 if ($delta > $n) {
                     if (!$is_highest_level &&
                             !$moved && ( $tagged || !$any_tagged)) {
                         $log->debug("Moving history level: $f -> $f2");
                         rename $f, $f2;
                         $moved++;
                         if ($f ne $f[0]) {
                             rename $f[0], "$f[0]t";
                         }
                     } else {
                         $log->debug("Removing history: $f ...");
                         system "nice -n19 rm -rf " . shell_quote($f);
                     }
                 }
             }
         }
     }
 }
 
 1;
 
 __END__
 
### File/RsyBak/Packed.pm ###
 package File::RsyBak::Packed;
 
 our $DATE = '2015-10-22'; 
 our $VERSION = '0.29'; 
 
 
 1;
 
 __END__
 
### File/Slurp/Tiny.pm ###
 package File::Slurp::Tiny;
 $File::Slurp::Tiny::VERSION = '0.004';
 use strict;
 use warnings;
 
 use Carp 'croak';
 use Exporter 5.57 'import';
 use File::Spec::Functions 'catfile';
 use FileHandle;
 our @EXPORT_OK = qw/read_file read_lines write_file read_dir/;
 
 my $default_layer = $^O eq 'MSWin32' ? ':crlf' : ':unix';
 
 sub read_file {
 	my ($filename, %options) = @_;
 	my $layer = $options{binmode} || $default_layer;
 	my $buf_ref = defined $options{buf_ref} ? $options{buf_ref} : \my $buf;
 
 	open my $fh, "<$layer", $filename or croak "Couldn't open $filename: $!";
 	if (my $size = -s $fh) {
 		my ($pos, $read) = 0;
 		do {
 			defined($read = read $fh, ${$buf_ref}, $size - $pos, $pos) or croak "Couldn't read $filename: $!";
 			$pos += $read;
 		} while ($read && $pos < $size);
 	}
 	else {
 		${$buf_ref} = do { local $/; <$fh> };
 	}
 	close $fh;
 	return if not defined wantarray or $options{buf_ref};
 	return $options{scalar_ref} ? $buf_ref : $buf;
 }
 
 sub read_lines {
 	my ($filename, %options) = @_;
 	my $layer = delete $options{binmode} || ':';
 	
 	open my $fh, "<$layer", $filename or croak "Couldn't open $filename: $!";
 	return <$fh> if not %options;
 	my @buf = <$fh>;
 	close $fh;
 	chomp @buf if $options{chomp};
 	return $options{array_ref} ? \@buf : @buf;
 }
 
 sub write_file {
 	my ($filename, undef, %options) = @_;
 	my $layer = $options{binmode} || $default_layer;
 	my $mode = $options{append} ? '>>' : '>';
 	my $buf_ref = defined $options{buf_ref} ? $options{buf_ref} : \$_[1];
 
 	open my $fh, $mode.$layer, $filename or croak "Couldn't open $filename: $!";
 	$fh->autoflush(1);
 	print $fh ${$buf_ref} or croak "Couldn't write to $filename: $!";
 	close $fh or croak "Couldn't close $filename: $!";
 	return;
 }
 
 sub read_dir {
 	my ($dirname, %options) = @_;
 	opendir my ($dir), $dirname or croak "Could not open $dirname: $!";
 	my @ret = grep { not m/ \A \.\.? \z /x } readdir $dir;
 	@ret = map { catfile($dirname, $_) } @ret if $options{prefix};
 	closedir $dir;
 	return @ret;
 }
 
 1;
 
 
 __END__
 
### File/Which.pm ###
 package File::Which;
 
 use strict;
 use warnings;
 use Exporter   ();
 use File::Spec ();
 
 our $VERSION = '1.19'; 
 
 
 our @ISA       = 'Exporter';
 our @EXPORT    = 'which';
 our @EXPORT_OK = 'where';
 
 use constant IS_VMS => ($^O eq 'VMS');
 use constant IS_MAC => ($^O eq 'MacOS');
 use constant IS_DOS => ($^O eq 'MSWin32' or $^O eq 'dos' or $^O eq 'os2');
 use constant IS_CYG => ($^O eq 'cygwin');
 
 my @PATHEXT = ('');
 if ( IS_DOS ) {
   if ( $ENV{PATHEXT} ) {
     push @PATHEXT, split ';', $ENV{PATHEXT};
   } else {
     push @PATHEXT, qw{.com .exe .bat};
   }
 } elsif ( IS_VMS ) {
   push @PATHEXT, qw{.exe .com};
 } elsif ( IS_CYG ) {
   push @PATHEXT, qw{.exe .com};
 }
 
 
 sub which {
   my ($exec) = @_;
 
   return undef unless $exec;
 
   my $all = wantarray;
   my @results = ();
 
   if ( IS_VMS ) {
     my $symbol = `SHOW SYMBOL $exec`;
     chomp($symbol);
     unless ( $? ) {
       return $symbol unless $all;
       push @results, $symbol;
     }
   }
   if ( IS_MAC ) {
     my @aliases = split /\,/, $ENV{Aliases};
     foreach my $alias ( @aliases ) {
       if ( lc($alias) eq lc($exec) ) {
         chomp(my $file = `Alias $alias`);
         last unless $file;  
         return $file unless $all;
         push @results, $file;
         last;
       }
     }
   }
 
   return $exec
           if !IS_VMS and !IS_MAC and !IS_DOS and $exec =~ /\// and -f $exec and -x $exec;
 
   my @path = File::Spec->path;
   if ( IS_DOS or IS_VMS or IS_MAC ) {
     unshift @path, File::Spec->curdir;
   }
 
   foreach my $base ( map { File::Spec->catfile($_, $exec) } @path ) {
     for my $ext ( @PATHEXT ) {
       my $file = $base.$ext;
 
       next if -d $file;
 
       if (
         -x _
         or (
           IS_MAC
           ||
           (
             ( IS_DOS or IS_CYG )
             and
             grep {
               $file =~ /$_\z/i
             } @PATHEXT[1..$#PATHEXT]
           )
           and -e _
         )
       ) {
         return $file unless $all;
         push @results, $file;
       }
     }
   }
 
   if ( $all ) {
     return @results;
   } else {
     return undef;
   }
 }
 
 
 sub where {
   my @res = which($_[0]);
   return @res;
 }
 
 1;
 
 __END__
 
### File/Write/Rotate.pm ###
 package File::Write::Rotate;
 
 our $DATE = '2015-10-20'; 
 our $VERSION = '0.29'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 
 use Carp;
 use File::Spec;
 use IO::Compress::Gzip qw(gzip $GzipError);
 use Scalar::Util qw(weaken);
 use Time::HiRes 'time';
 
 our $Debug;
 
 sub new {
     my $class = shift;
     my %args0 = @_;
 
     my %args;
 
     defined($args{dir} = delete $args0{dir})
         or croak "Please specify dir";
     defined($args{prefix} = delete $args0{prefix})
         or croak "Please specify prefix";
     $args{suffix} = delete($args0{suffix}) // "";
 
     $args{size} = delete($args0{size}) // 0;
 
     $args{period} = delete($args0{period});
     if ($args{period}) {
         $args{period} =~ /\A(daily|day|month|monthly|year|yearly)\z/
             or croak "Invalid period, please use daily/monthly/yearly";
     }
 
     for (map {"hook_$_"} qw(before_rotate after_rotate after_create
                             before_write a)) {
         next unless $args0{$_};
         $args{$_} = delete($args0{$_});
         croak "Invalid $_, please supply a coderef"
             unless ref($args{$_}) eq 'CODE';
     }
 
     if (!$args{period} && !$args{size}) {
         $args{size} = 10 * 1024 * 1024;
     }
 
     $args{histories} = delete($args0{histories}) // 10;
 
     $args{binmode} = delete($args0{binmode});
 
     $args{buffer_size} = delete($args0{buffer_size});
 
     $args{lock_mode} = delete($args0{lock_mode}) // 'write';
     $args{lock_mode} =~ /\A(none|write|exclusive)\z/
         or croak "Invalid lock_mode, please use none/write/exclusive";
 
     $args{rotate_probability} = delete($args0{rotate_probability});
     if (defined $args{rotate_probability}) {
         $args{rotate_probability} > 0 && $args{rotate_probability} < 1.0
             or croak "Invalid rotate_probability, must be 0 < x < 1";
     }
 
     if (keys %args0) {
         croak "Unknown arguments to new(): ".join(", ", sort keys %args0);
     }
 
     $args{_buffer} = [];
 
     my $self = bless \%args, $class;
 
     $self->{_exclusive_lock} = $self->_get_lock
         if $self->{lock_mode} eq 'exclusive';
 
     $self;
 }
 
 sub buffer_size {
     my $self = shift;
     if (@_) {
         my $old = $self->{buffer_size};
         $self->{buffer_size} = $_[0];
         return $old;
     } else {
         return $self->{buffer_size};
     }
 }
 
 sub handle {
     my $self = shift;
     $self->{_fh};
 }
 
 sub path {
     my $self = shift;
     $self->{_fp};
 }
 
 sub _file_path {
     my ($self) = @_;
 
     $self->{_now} = time();
 
     my @lt = localtime($self->{_now});
     $lt[5] += 1900;
     $lt[4]++;
 
     my $period;
     if ($self->{period}) {
         if ($self->{period} =~ /year/i) {
             $period = sprintf("%04d", $lt[5]);
         } elsif ($self->{period} =~ /month/) {
             $period = sprintf("%04d-%02d", $lt[5], $lt[4]);
         } elsif ($self->{period} =~ /day|daily/) {
             $period = sprintf("%04d-%02d-%02d", $lt[5], $lt[4], $lt[3]);
         }
     } else {
         $period = "";
     }
 
     my $path = join(
         '',
         $self->{dir}, '/',
         $self->{prefix},
         length($period) ? ".$period" : "",
         $self->{suffix},
     );
     if (wantarray) {
         return ($path, $period);
     } else {
         return $path;
     }
 }
 
 sub lock_file_path {
     my ($self) = @_;
     return File::Spec->catfile($self->{dir}, $self->{prefix} . '.lck');
 }
 
 sub _get_lock {
     my ($self) = @_;
     return undef if $self->{lock_mode} eq 'none';
     return $self->{_weak_lock} if defined($self->{_weak_lock});
 
     require File::Flock::Retry;
     my $lock = File::Flock::Retry->lock($self->lock_file_path);
     $self->{_weak_lock} = $lock;
     weaken $self->{_weak_lock};
     return $lock;
 }
 
 sub _get_files {
     my ($self) = @_;
 
     opendir my ($dh), $self->{dir} or do {
         warn "Can't opendir '$self->{dir}': $!";
         return;
     };
 
     my @files;
     while (my $e = readdir($dh)) {
         my $cs = $1 if $e =~ s/(\.gz)\z//; 
         next unless $e =~ /\A\Q$self->{prefix}\E
                            (?:\. (?<period>\d{4}(?:-\d\d(?:-\d\d)?)?) )?
                            \Q$self->{suffix}\E
                            (?:\. (?<rotate_suffix>\d+) )?
                            \z
                           /x;
         push @files,
           [ $e, $+{rotate_suffix} // 0, $+{period} // "", $cs // "" ];
     }
     closedir($dh);
 
     [ sort { $a->[2] cmp $b->[2] || $b->[1] <=> $a->[1] } @files ];
 }
 
 sub _rotate_and_delete {
     my ($self, %opts) = @_;
 
     my $delete_only = $opts{delete_only};
     my $lock = $self->_get_lock;
   CASE:
     {
         my $files = $self->_get_files or last CASE;
 
         if (-f "$self->{dir}/$self->{prefix}-compress.pid") {
             warn "Compression is in progress, rotation is postponed";
             last CASE;
         }
 
         $self->{hook_before_rotate}->($self, [map {$_->[0]} @$files])
             if $self->{hook_before_rotate};
 
         my @deleted;
         my @renamed;
 
         my $i;
         my $dir = $self->{dir};
         my $rotating_period = @$files ? $files->[-1][2] : undef;
         for my $f (@$files) {
             my ($orig, $rs, $period, $cs) = @$f;
             $i++;
 
 
             ($orig) = $orig =~ /(.*)/s; 
 
             if ($i <= @$files - $self->{histories}) {
                 say "DEBUG: Deleting old rotated file $dir/$orig$cs ..."
                     if $Debug;
                 if (unlink "$dir/$orig$cs") {
                     push @deleted, "$orig$cs";
                 } else {
                     warn "Can't delete $dir/$orig$cs: $!";
                 }
                 next;
             }
             if (!$delete_only && defined($rotating_period) && $period eq $rotating_period) {
                 my $new = $orig;
                 if ($rs) {
                     $new =~ s/\.(\d+)\z/"." . ($1+1)/e;
                 } else {
                     $new .= ".1";
                 }
                 if ($new ne $orig) {
                     say "DEBUG: Renaming rotated file $dir/$orig$cs -> ".
                         "$dir/$new$cs ..." if $Debug;
                     if (rename "$dir/$orig$cs", "$dir/$new$cs") {
                         push @renamed, "$new$cs";
                     } else {
                         warn "Can't rename '$dir/$orig$cs' -> '$dir/$new$cs': $!";
                     }
                 }
             }
         }
 
         $self->{hook_after_rotate}->($self, \@renamed, \@deleted)
             if $self->{hook_after_rotate};
     } 
 }
 
 sub _open {
     my $self = shift;
 
     my ($fp, $period) = $self->_file_path;
     open $self->{_fh}, ">>", $fp or die "Can't open '$fp': $!";
     if (defined $self->{binmode}) {
         binmode $self->{_fh}, $self->{binmode}
           or die "Can't set PerlIO layer on '$fp': $!";
     }
     my $oldfh = select $self->{_fh};
     $| = 1;
     select $oldfh;    
     $self->{_fp} = $fp;
     $self->{hook_after_create}->($self) if $self->{hook_after_create};
 }
 
 sub _rotate_and_open {
 
     my $self = shift;
     my ($do_open, $do_rotate) = @_;
     my $fp;
     my %rotate_params;
 
   CASE:
     {
         if ($self->{rotate_probability} && $self->{_fh}) {
             last CASE if rand() > $self->{rotate_probability};
         }
 
         $fp = $self->_file_path;
         unless (-e $fp) {
             $do_open++;
             $do_rotate++;
             $rotate_params{delete_only} = 1;
             last CASE;
         }
 
         unless ($self->{_fh}) {
             $self->_open;
         }
 
         if ($self->{_fp} ne $fp) {
             $do_rotate++;
             $rotate_params{delete_only} = 1;
             last CASE;
         }
 
         my $inode;
 
         if ($self->{size} > 0) {
 
             my @st   = stat($self->{_fh});
             my $size = $st[7];
             $inode = $st[1];
 
             if ($size >= $self->{size}) {
                 say "DEBUG: Size of $self->{_fp} is $size, exceeds $self->{size}, rotating ..."
                     if $Debug;
                 $do_rotate++;
                 last CASE;
             } else {
                 my @st = stat($fp);
                 die "Can't stat '$fp': $!" unless @st;
                 my $finode = $st[1];
 
                 if (defined($inode) && $finode != $inode) {
                     $do_open++;
                 }
             }
 
         }
     } 
 
     $self->_rotate_and_delete(%rotate_params) if $do_rotate;
     $self->_open if $do_rotate || $do_open;    
 }
 
 sub write {
     my $self = shift;
 
 
 
     my @msg = (map( {@$_} @{ $self->{_buffer} } ), @_);
 
     eval {
         my $lock = $self->_get_lock;
 
         $self->_rotate_and_open;
 
         $self->{hook_before_write}->($self, \@msg, $self->{_fh})
             if $self->{hook_before_write};
 
         print { $self->{_fh} } @msg;
         $self->{_buffer} = [];
 
     };
     my $err = $@;
 
     if ($err) {
         if (($self->{buffer_size} // 0) > @{ $self->{_buffer} }) {
             push @{ $self->{_buffer} }, [@_];
         } else {
             die join(
                 "",
                 "Can't write",
                 (
                     @{ $self->{_buffer} }
                     ? " (buffer is full, "
                       . ~~@{ $self->{_buffer} }
                       . " message(s))"
                     : ""
                 ),
                 ": $err, message(s)=",
                 @msg
             );
         }
     }
 }
 
 sub compress {
     my ($self) = shift;
 
     require Proc::PID::File;
 
     my $lock           = $self->_get_lock;
     my $files_ref        = $self->_get_files;
     my $done_compression = 0;
 
     if (@{$files_ref}) {
         my $pid = Proc::PID::File->new(
             dir    => $self->{dir},
             name   => "$self->{prefix}-compress",
             verify => 1,
         );
         my $latest_period = $files_ref->[-1][2];
 
         if ($pid->alive) {
             warn "Another compression is in progress";
         } else {
             my @tocompress;
             for my $file_ref (@{$files_ref}) {
                 my ($orig, $rs, $period, $cs) = @{ $file_ref };
                 next if $cs; 
                 next if !$self->{period} && !$rs; 
                 next if  $self->{period} && $period eq $latest_period; 
                 push @tocompress, File::Spec->catfile($self->{dir}, $orig);
             }
 
             if (@tocompress) {
                 for my $file (@tocompress) {
                     gzip($file => "$file.gz")
                         or do { warn "gzip failed: $GzipError\n"; next };
                     unlink $file;
                 }
                 $done_compression = 1;
             }
         }
     }
 
     return $done_compression;
 
 }
 
 sub DESTROY {
     my ($self) = @_;
 
     unlink "$self->{dir}/$self->{prefix}-compress.pid";
 }
 
 1;
 
 
 __END__
 
### Function/Fallback/CoreOrPP.pm ###
 package Function::Fallback::CoreOrPP;
 
 use 5.010001;
 use strict;
 use warnings;
 
 our $VERSION = '0.06'; 
 
 our $USE_NONCORE_XS_FIRST = 1;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(
                        clone
                        unbless
                        uniq
                );
 
 sub clone {
     my $data = shift;
     goto FALLBACK unless $USE_NONCORE_XS_FIRST;
     goto FALLBACK unless eval { require Data::Clone; 1 };
 
   STANDARD:
     return Data::Clone::clone($data);
 
   FALLBACK:
     require Clone::PP;
     return Clone::PP::clone($data);
 }
 
 sub _unbless_fallback {
     my $ref = shift;
 
     my $r = ref($ref);
     return $ref unless $r;
 
     my ($r2, $r3) = "$ref" =~ /(.+)=(.+?)\(/
         or return $ref;
 
     if ($r3 eq 'HASH') {
         return { %$ref };
     } elsif ($r3 eq 'ARRAY') {
         return [ @$ref ];
     } elsif ($r3 eq 'SCALAR') {
         return \( my $copy = ${$ref} );
     } else {
         die "Can't handle $ref";
     }
 }
 
 sub unbless {
     my $ref = shift;
 
     goto FALLBACK unless $USE_NONCORE_XS_FIRST;
     goto FALLBACK unless eval { require Acme::Damn; 1 };
 
   STANDARD:
     return Acme::Damn::damn($ref);
 
   FALLBACK:
     return _unbless_fallback($ref);
 }
 
 sub uniq {
     goto FALLBACK unless $USE_NONCORE_XS_FIRST;
     goto FALLBACK unless eval { require List::MoreUtils; 1 };
 
   STANDARD:
     return List::MoreUtils::uniq(@_);
 
   FALLBACK:
     my %h;
     my @res;
     for (@_) {
         push @res, $_ unless $h{$_}++;
     }
     return @res;
 }
 
 1;
 
 __END__
 
### Getopt/Long/Negate/EN.pm ###
 package Getopt::Long::Negate::EN;
 
 our $DATE = '2015-03-19'; 
 our $VERSION = '0.01'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Exporter qw(import);
 our @EXPORT_OK = qw(negations_for_option);
 
 sub negations_for_option {
     my $word = shift;
     if    ($word =~ /\Awith([_-].+)/   ) { return ("without$1") }
     elsif ($word =~ /\Awithout([_-].+)/) { return ("with$1")    }
     elsif ($word =~ /\Ais([_-].+)/     ) { return ("isnt$1")    }
     elsif ($word =~ /\Aisnt([_-].+)/   ) { return ("is$1")      }
     elsif ($word =~ /\Aare([_-].+)/    ) { return ("arent$1")   }
     elsif ($word =~ /\Aarent([_-].+)/  ) { return ("are$1")     }
     elsif ($word =~ /\Ano[_-](.+)/     ) { return ($1)          }
     else {
         return ("no-$word", "no$word");
     }
 }
 
 1;
 
 __END__
 
### Getopt/Long/Util.pm ###
 package Getopt::Long::Util;
 
 our $DATE = '2015-06-11'; 
 our $VERSION = '0.83'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(
                        parse_getopt_long_opt_spec
                        humanize_getopt_long_opt_spec
                        detect_getopt_long_script
                );
 
 our %SPEC;
 
 $SPEC{parse_getopt_long_opt_spec} = {
     v => 1.1,
     summary => 'Parse a single Getopt::Long option specification',
     description => <<'_',
 
 Will produce a hash with some keys: `opts` (array of option names, in the order
 specified in the opt spec), `type` (string, type name), `desttype` (either '',
 or '@' or '%'), `is_neg` (true for `--opt!`), `is_inc` (true for `--opt+`),
 `min_vals` (int, usually 0 or 1), `max_vals` (int, usually 0 or 1 except for
 option that requires multiple values),
 
 Will return undef if it can't parse the string.
 
 _
     args => {
         optspec => {
             schema => 'str*',
             req => 1,
             pos => 0,
         },
     },
     args_as => 'array',
     result_naked => 1,
     result => {
         schema => 'hash*',
     },
     examples => [
         {
             args => {optspec => 'help|h|?'},
             result => {dash_prefix=>'', opts=>['help', 'h', '?']},
         },
         {
             args => {optspec=>'--foo=s'},
             result => {dash_prefix=>'--', opts=>['foo'], type=>'s', desttype=>''},
         },
     ],
 };
 sub parse_getopt_long_opt_spec {
     my $optspec = shift;
     $optspec =~ qr/\A
                (?P<dash_prefix>-{0,2})
                (?P<name>[A-Za-z0-9_][A-Za-z0-9_-]*)
                (?P<aliases> (?: \| (?:[^:|!+=:-][^:|!+=:]*) )*)?
                (?:
                    (?P<is_neg>!) |
                    (?P<is_inc>\+) |
                    (?:
                        =
                        (?P<type>[siof])
                        (?P<desttype>|[%@])?
                        (?:
                            \{
                            (?: (?P<min_vals>\d+), )?
                            (?P<max_vals>\d+)
                            \}
                        )?
                    ) |
                    (?:
                        :
                        (?P<opttype>[siof])
                        (?P<desttype>|[%@])
                    ) |
                    (?:
                        :
                        (?P<optnum>\d+)
                        (?P<desttype>|[%@])
                    )
                    (?:
                        :
                        (?P<optplus>\+)
                        (?P<desttype>|[%@])
                    )
                )?
                \z/x
                    or return undef;
     my %res = %+;
 
     if ($res{aliases}) {
         my @als;
         for my $al (split /\|/, $res{aliases}) {
             next unless length $al;
             next if $al eq $res{name};
             next if grep {$_ eq $al} @als;
             push @als, $al;
         }
         $res{opts} = [$res{name}, @als];
     } else {
         $res{opts} = [$res{name}];
     }
     delete $res{name};
     delete $res{aliases};
 
     $res{is_neg} = 1 if $res{is_neg};
     $res{is_inc} = 1 if $res{is_inc};
 
     \%res;
 }
 
 $SPEC{humanize_getopt_long_opt_spec} = {
     v => 1.1,
     description => <<'_',
 
 Convert `Getopt::Long` option specification like `help|h|?` or `--foo=s` or
 `debug!` into, respectively, `--help, -h, -?` or `--foo=s` or `--(no)debug`.
 Will die if can't parse the string. The output is suitable for including in
 help/usage text.
 
 _
     args => {
         optspec => {
             schema => 'str*',
             req => 1,
             pos => 0,
         },
     },
     args_as => 'array',
     result_naked => 1,
     result => {
         schema => 'str*',
     },
 };
 sub humanize_getopt_long_opt_spec {
     my $optspec = shift;
 
     my $parse = parse_getopt_long_opt_spec($optspec)
         or die "Can't parse opt spec $optspec";
 
     my $res = '';
     my $i = 0;
     for (@{ $parse->{opts} }) {
         $i++;
         $res .= ", " if length($res);
         if ($parse->{is_neg} && length($_) > 1) {
             $res .= "--(no)$_";
         } else {
             if (length($_) > 1) {
                 $res .= "--$_";
             } else {
                 $res .= "-$_";
             }
             $res .= "=$parse->{type}" if $i==1 && $parse->{type};
         }
     }
     $res;
 }
 
 $SPEC{detect_getopt_long_script} = {
     v => 1.1,
     summary => 'Detect whether a file is a Getopt::Long-based CLI script',
     description => <<'_',
 
 The criteria are:
 
 * the file must exist and readable;
 
 * (optional, if `include_noexec` is false) file must have its executable mode
   bit set;
 
 * content must start with a shebang C<#!>;
 
 * either: must be perl script (shebang line contains 'perl') and must contain
   something like `use Getopt::Long`;
 
 _
     args => {
         filename => {
             summary => 'Path to file to be checked',
             schema => 'str*',
             description => <<'_',
 
 Either `filename` or `string` must be specified.
 
 _
         },
         string => {
             summary => 'Path to file to be checked',
             schema => 'buf*',
             description => <<'_',
 
 Either `file` or `string` must be specified.
 
 _
         },
         include_noexec => {
             summary => 'Include scripts that do not have +x mode bit set',
             schema  => 'bool*',
             default => 1,
         },
     },
 };
 sub detect_getopt_long_script {
     my %args = @_;
 
     (defined($args{filename}) xor defined($args{string}))
         or return [400, "Please specify either filename or string"];
     my $include_noexec  = $args{include_noexec}  // 1;
 
     my $yesno = 0;
     my $reason = "";
 
     my $str = $args{string};
   DETECT:
     {
         if (defined $args{filename}) {
             my $fn = $args{filename};
             unless (-f $fn) {
                 $reason = "'$fn' is not a file";
                 last;
             };
             if (!$include_noexec && !(-x _)) {
                 $reason = "'$fn' is not an executable";
                 last;
             }
             my $fh;
             unless (open $fh, "<", $fn) {
                 $reason = "Can't be read";
                 last;
             }
             read $fh, $str, 2;
             unless ($str eq '#!') {
                 $reason = "Does not start with a shebang (#!) sequence";
                 last;
             }
             my $shebang = <$fh>;
             unless ($shebang =~ /perl/) {
                 $reason = "Does not have 'perl' in the shebang line";
                 last;
             }
             seek $fh, 0, 0;
             {
                 local $/;
                 $str = <$fh>;
             }
         }
         unless ($str =~ /\A#!/) {
             $reason = "Does not start with a shebang (#!) sequence";
             last;
         }
         unless ($str =~ /\A#!.*perl/) {
             $reason = "Does not have 'perl' in the shebang line";
             last;
         }
         if ($str =~ /^\s*(use|require)\s+Getopt::Long(\s|;)/m) {
             $yesno = 1;
             last DETECT;
         }
         $reason = "Can't find any statement requiring Getopt::Long module";
     } 
 
     [200, "OK", $yesno, {"func.reason"=>$reason}];
 }
 
 
 __END__
 
### HTML/Entities.pm ###
 package HTML::Entities;
 
 
 use strict;
 use vars qw(@ISA @EXPORT @EXPORT_OK $VERSION);
 use vars qw(%entity2char %char2entity);
 
 require 5.004;
 require Exporter;
 @ISA = qw(Exporter);
 
 @EXPORT = qw(encode_entities decode_entities _decode_entities);
 @EXPORT_OK = qw(%entity2char %char2entity encode_entities_numeric);
 
 $VERSION = "3.69";
 sub Version { $VERSION; }
 
 require HTML::Parser;  
 
 
 %entity2char = (
  amp    => '&',  
 'gt'    => '>',  
 'lt'    => '<',  
  quot   => '"',  
  apos   => "'",  
 
  AElig	=> chr(198),  
  Aacute	=> chr(193),  
  Acirc	=> chr(194),  
  Agrave	=> chr(192),  
  Aring	=> chr(197),  
  Atilde	=> chr(195),  
  Auml	=> chr(196),  
  Ccedil	=> chr(199),  
  ETH	=> chr(208),  
  Eacute	=> chr(201),  
  Ecirc	=> chr(202),  
  Egrave	=> chr(200),  
  Euml	=> chr(203),  
  Iacute	=> chr(205),  
  Icirc	=> chr(206),  
  Igrave	=> chr(204),  
  Iuml	=> chr(207),  
  Ntilde	=> chr(209),  
  Oacute	=> chr(211),  
  Ocirc	=> chr(212),  
  Ograve	=> chr(210),  
  Oslash	=> chr(216),  
  Otilde	=> chr(213),  
  Ouml	=> chr(214),  
  THORN	=> chr(222),  
  Uacute	=> chr(218),  
  Ucirc	=> chr(219),  
  Ugrave	=> chr(217),  
  Uuml	=> chr(220),  
  Yacute	=> chr(221),  
  aacute	=> chr(225),  
  acirc	=> chr(226),  
  aelig	=> chr(230),  
  agrave	=> chr(224),  
  aring	=> chr(229),  
  atilde	=> chr(227),  
  auml	=> chr(228),  
  ccedil	=> chr(231),  
  eacute	=> chr(233),  
  ecirc	=> chr(234),  
  egrave	=> chr(232),  
  eth	=> chr(240),  
  euml	=> chr(235),  
  iacute	=> chr(237),  
  icirc	=> chr(238),  
  igrave	=> chr(236),  
  iuml	=> chr(239),  
  ntilde	=> chr(241),  
  oacute	=> chr(243),  
  ocirc	=> chr(244),  
  ograve	=> chr(242),  
  oslash	=> chr(248),  
  otilde	=> chr(245),  
  ouml	=> chr(246),  
  szlig	=> chr(223),  
  thorn	=> chr(254),  
  uacute	=> chr(250),  
  ucirc	=> chr(251),  
  ugrave	=> chr(249),  
  uuml	=> chr(252),  
  yacute	=> chr(253),  
  yuml	=> chr(255),  
 
  copy   => chr(169),  
  reg    => chr(174),  
  nbsp   => chr(160),  
 
  iexcl  => chr(161),
  cent   => chr(162),
  pound  => chr(163),
  curren => chr(164),
  yen    => chr(165),
  brvbar => chr(166),
  sect   => chr(167),
  uml    => chr(168),
  ordf   => chr(170),
  laquo  => chr(171),
 'not'   => chr(172),    
  shy    => chr(173),
  macr   => chr(175),
  deg    => chr(176),
  plusmn => chr(177),
  sup1   => chr(185),
  sup2   => chr(178),
  sup3   => chr(179),
  acute  => chr(180),
  micro  => chr(181),
  para   => chr(182),
  middot => chr(183),
  cedil  => chr(184),
  ordm   => chr(186),
  raquo  => chr(187),
  frac14 => chr(188),
  frac12 => chr(189),
  frac34 => chr(190),
  iquest => chr(191),
 'times' => chr(215),    
  divide => chr(247),
 
  ( $] > 5.007 ? (
   'OElig;'    => chr(338),
   'oelig;'    => chr(339),
   'Scaron;'   => chr(352),
   'scaron;'   => chr(353),
   'Yuml;'     => chr(376),
   'fnof;'     => chr(402),
   'circ;'     => chr(710),
   'tilde;'    => chr(732),
   'Alpha;'    => chr(913),
   'Beta;'     => chr(914),
   'Gamma;'    => chr(915),
   'Delta;'    => chr(916),
   'Epsilon;'  => chr(917),
   'Zeta;'     => chr(918),
   'Eta;'      => chr(919),
   'Theta;'    => chr(920),
   'Iota;'     => chr(921),
   'Kappa;'    => chr(922),
   'Lambda;'   => chr(923),
   'Mu;'       => chr(924),
   'Nu;'       => chr(925),
   'Xi;'       => chr(926),
   'Omicron;'  => chr(927),
   'Pi;'       => chr(928),
   'Rho;'      => chr(929),
   'Sigma;'    => chr(931),
   'Tau;'      => chr(932),
   'Upsilon;'  => chr(933),
   'Phi;'      => chr(934),
   'Chi;'      => chr(935),
   'Psi;'      => chr(936),
   'Omega;'    => chr(937),
   'alpha;'    => chr(945),
   'beta;'     => chr(946),
   'gamma;'    => chr(947),
   'delta;'    => chr(948),
   'epsilon;'  => chr(949),
   'zeta;'     => chr(950),
   'eta;'      => chr(951),
   'theta;'    => chr(952),
   'iota;'     => chr(953),
   'kappa;'    => chr(954),
   'lambda;'   => chr(955),
   'mu;'       => chr(956),
   'nu;'       => chr(957),
   'xi;'       => chr(958),
   'omicron;'  => chr(959),
   'pi;'       => chr(960),
   'rho;'      => chr(961),
   'sigmaf;'   => chr(962),
   'sigma;'    => chr(963),
   'tau;'      => chr(964),
   'upsilon;'  => chr(965),
   'phi;'      => chr(966),
   'chi;'      => chr(967),
   'psi;'      => chr(968),
   'omega;'    => chr(969),
   'thetasym;' => chr(977),
   'upsih;'    => chr(978),
   'piv;'      => chr(982),
   'ensp;'     => chr(8194),
   'emsp;'     => chr(8195),
   'thinsp;'   => chr(8201),
   'zwnj;'     => chr(8204),
   'zwj;'      => chr(8205),
   'lrm;'      => chr(8206),
   'rlm;'      => chr(8207),
   'ndash;'    => chr(8211),
   'mdash;'    => chr(8212),
   'lsquo;'    => chr(8216),
   'rsquo;'    => chr(8217),
   'sbquo;'    => chr(8218),
   'ldquo;'    => chr(8220),
   'rdquo;'    => chr(8221),
   'bdquo;'    => chr(8222),
   'dagger;'   => chr(8224),
   'Dagger;'   => chr(8225),
   'bull;'     => chr(8226),
   'hellip;'   => chr(8230),
   'permil;'   => chr(8240),
   'prime;'    => chr(8242),
   'Prime;'    => chr(8243),
   'lsaquo;'   => chr(8249),
   'rsaquo;'   => chr(8250),
   'oline;'    => chr(8254),
   'frasl;'    => chr(8260),
   'euro;'     => chr(8364),
   'image;'    => chr(8465),
   'weierp;'   => chr(8472),
   'real;'     => chr(8476),
   'trade;'    => chr(8482),
   'alefsym;'  => chr(8501),
   'larr;'     => chr(8592),
   'uarr;'     => chr(8593),
   'rarr;'     => chr(8594),
   'darr;'     => chr(8595),
   'harr;'     => chr(8596),
   'crarr;'    => chr(8629),
   'lArr;'     => chr(8656),
   'uArr;'     => chr(8657),
   'rArr;'     => chr(8658),
   'dArr;'     => chr(8659),
   'hArr;'     => chr(8660),
   'forall;'   => chr(8704),
   'part;'     => chr(8706),
   'exist;'    => chr(8707),
   'empty;'    => chr(8709),
   'nabla;'    => chr(8711),
   'isin;'     => chr(8712),
   'notin;'    => chr(8713),
   'ni;'       => chr(8715),
   'prod;'     => chr(8719),
   'sum;'      => chr(8721),
   'minus;'    => chr(8722),
   'lowast;'   => chr(8727),
   'radic;'    => chr(8730),
   'prop;'     => chr(8733),
   'infin;'    => chr(8734),
   'ang;'      => chr(8736),
   'and;'      => chr(8743),
   'or;'       => chr(8744),
   'cap;'      => chr(8745),
   'cup;'      => chr(8746),
   'int;'      => chr(8747),
   'there4;'   => chr(8756),
   'sim;'      => chr(8764),
   'cong;'     => chr(8773),
   'asymp;'    => chr(8776),
   'ne;'       => chr(8800),
   'equiv;'    => chr(8801),
   'le;'       => chr(8804),
   'ge;'       => chr(8805),
   'sub;'      => chr(8834),
   'sup;'      => chr(8835),
   'nsub;'     => chr(8836),
   'sube;'     => chr(8838),
   'supe;'     => chr(8839),
   'oplus;'    => chr(8853),
   'otimes;'   => chr(8855),
   'perp;'     => chr(8869),
   'sdot;'     => chr(8901),
   'lceil;'    => chr(8968),
   'rceil;'    => chr(8969),
   'lfloor;'   => chr(8970),
   'rfloor;'   => chr(8971),
   'lang;'     => chr(9001),
   'rang;'     => chr(9002),
   'loz;'      => chr(9674),
   'spades;'   => chr(9824),
   'clubs;'    => chr(9827),
   'hearts;'   => chr(9829),
   'diams;'    => chr(9830),
  ) : ())
 );
 
 
 while (my($entity, $char) = each(%entity2char)) {
     $entity =~ s/;\z//;
     $char2entity{$char} = "&$entity;";
 }
 delete $char2entity{"'"};  
 
 for (0 .. 255) {
     next if exists $char2entity{chr($_)};
     $char2entity{chr($_)} = "&#$_;";
 }
 
 my %subst;  
 
 sub encode_entities
 {
     return undef unless defined $_[0];
     my $ref;
     if (defined wantarray) {
 	my $x = $_[0];
 	$ref = \$x;     
     } else {
 	$ref = \$_[0];  
     }
     if (defined $_[1] and length $_[1]) {
 	unless (exists $subst{$_[1]}) {
 	    my $chars = $_[1];
 	    $chars =~ s,(?<!\\)([]/]),\\$1,g;
 	    $chars =~ s,(?<!\\)\\\z,\\\\,;
 	    my $code = "sub {\$_[0] =~ s/([$chars])/\$char2entity{\$1} || num_entity(\$1)/ge; }";
 	    $subst{$_[1]} = eval $code;
 	    die( $@ . " while trying to turn range: \"$_[1]\"\n "
 	      . "into code: $code\n "
 	    ) if $@;
 	}
 	&{$subst{$_[1]}}($$ref);
     } else {
 	$$ref =~ s/([^\n\r\t !\#\$%\(-;=?-~])/$char2entity{$1} || num_entity($1)/ge;
     }
     $$ref;
 }
 
 sub encode_entities_numeric {
     local %char2entity;
     return &encode_entities;   
 }
 
 
 sub num_entity {
     sprintf "&#x%X;", ord($_[0]);
 }
 
 *encode = \&encode_entities;
 *encode_numeric = \&encode_entities_numeric;
 *encode_numerically = \&encode_entities_numeric;
 *decode = \&decode_entities;
 
 1;
### HTML/Filter.pm ###
 package HTML::Filter;
 
 use strict;
 use vars qw(@ISA $VERSION);
 
 require HTML::Parser;
 @ISA=qw(HTML::Parser);
 
 $VERSION = "3.57";
 
 sub declaration { $_[0]->output("<!$_[1]>")     }
 sub process     { $_[0]->output($_[2])          }
 sub comment     { $_[0]->output("<!--$_[1]-->") }
 sub start       { $_[0]->output($_[4])          }
 sub end         { $_[0]->output($_[2])          }
 sub text        { $_[0]->output($_[1])          }
 
 sub output      { print $_[1] }
 
 1;
 
 __END__
 
### HTML/HeadParser.pm ###
 package HTML::HeadParser;
 
 
 
 require HTML::Parser;
 @ISA = qw(HTML::Parser);
 
 use HTML::Entities ();
 
 use strict;
 use vars qw($VERSION $DEBUG);
 $VERSION = "3.71";
 
 
 sub new
 {
     my($class, $header) = @_;
     unless ($header) {
 	require HTTP::Headers;
 	$header = HTTP::Headers->new;
     }
 
     my $self = $class->SUPER::new(api_version => 3,
 				  start_h => ["start", "self,tagname,attr"],
 				  end_h   => ["end",   "self,tagname"],
 				  text_h  => ["text",  "self,text"],
 				  ignore_elements => [qw(script style)],
 				 );
     $self->{'header'} = $header;
     $self->{'tag'} = '';   
     $self->{'text'} = '';  
     $self;
 }
 
 
 sub header
 {
     my $self = shift;
     return $self->{'header'} unless @_;
     $self->{'header'}->header(@_);
 }
 
 sub as_string    
 {
     my $self = shift;
     $self->{'header'}->as_string;
 }
 
 sub flush_text   
 {
     my $self = shift;
     my $tag  = $self->{'tag'};
     my $text = $self->{'text'};
     $text =~ s/^\s+//;
     $text =~ s/\s+$//;
     $text =~ s/\s+/ /g;
     print "FLUSH $tag => '$text'\n"  if $DEBUG;
     if ($tag eq 'title') {
 	my $decoded;
 	$decoded = utf8::decode($text) if $self->utf8_mode && defined &utf8::decode;
 	HTML::Entities::decode($text);
 	utf8::encode($text) if $decoded;
 	$self->{'header'}->push_header(Title => $text);
     }
     $self->{'tag'} = $self->{'text'} = '';
 }
 
 
 sub start
 {
     my($self, $tag, $attr) = @_;  
     print "START[$tag]\n" if $DEBUG;
     $self->flush_text if $self->{'tag'};
     if ($tag eq 'meta') {
 	my $key = $attr->{'http-equiv'};
 	if (!defined($key) || !length($key)) {
 	    if ($attr->{name}) {
 		$key = "X-Meta-\u$attr->{name}";
 	    } elsif ($attr->{charset}) { 
 		$key = "X-Meta-Charset";
 		$self->{header}->push_header($key => $attr->{charset});
 		return;
 	    } else {
 		return;
 	    }
 	}
 	$key =~ s/:/-/g;
 	$self->{'header'}->push_header($key => $attr->{content});
     } elsif ($tag eq 'base') {
 	return unless exists $attr->{href};
 	(my $base = $attr->{href}) =~ s/^\s+//; $base =~ s/\s+$//; 
 	$self->{'header'}->push_header('Content-Base' => $base);
     } elsif ($tag eq 'isindex') {
 	$self->{'header'}->push_header(Isindex => $attr->{prompt} || '?');
     } elsif ($tag =~ /^(?:title|noscript|object|command)$/) {
 	$self->{'tag'} = $tag;
     } elsif ($tag eq 'link') {
 	return unless exists $attr->{href};
 	my $href = delete($attr->{href});
 	$href =~ s/^\s+//; $href =~ s/\s+$//; 
 	my $h_val = "<$href>";
 	for (sort keys %{$attr}) {
 	    next if $_ eq "/";  
 	    $h_val .= qq(; $_="$attr->{$_}");
 	}
 	$self->{'header'}->push_header(Link => $h_val);
     } elsif ($tag eq 'head' || $tag eq 'html') {
     } else {
 	$self->eof;
     }
 }
 
 sub end
 {
     my($self, $tag) = @_;
     print "END[$tag]\n" if $DEBUG;
     $self->flush_text if $self->{'tag'};
     $self->eof if $tag eq 'head';
 }
 
 sub text
 {
     my($self, $text) = @_;
     print "TEXT[$text]\n" if $DEBUG;
     unless ($self->{first_chunk}) {
 	if ($self->utf8_mode) {
 	    $text =~ s/^\xEF\xBB\xBF//;
 	}
 	else {
 	    $text =~ s/^\x{FEFF}//;
 	}
 	$self->{first_chunk}++;
     }
     my $tag = $self->{tag};
     if (!$tag && $text =~ /\S/) {
         $self->eof;
 	return;
     }
     return if $tag ne 'title';
     $self->{'text'} .= $text;
 }
 
 BEGIN {
     *utf8_mode = sub { 1 } unless HTML::Entities::UNICODE_SUPPORT;
 }
 
 1;
 
 __END__
 
 
### HTML/LinkExtor.pm ###
 package HTML::LinkExtor;
 
 require HTML::Parser;
 @ISA = qw(HTML::Parser);
 $VERSION = "3.69";
 
 
 use strict;
 use HTML::Tagset ();
 
 use vars qw(%LINK_ELEMENT);
 *LINK_ELEMENT = \%HTML::Tagset::linkElements;
 
 
 sub new
 {
     my($class, $cb, $base) = @_;
     my $self = $class->SUPER::new(
                     start_h => ["_start_tag", "self,tagname,attr"],
 		    report_tags => [keys %HTML::Tagset::linkElements],
 	       );
     $self->{extractlink_cb} = $cb;
     if ($base) {
 	require URI;
 	$self->{extractlink_base} = URI->new($base);
     }
     $self;
 }
 
 sub _start_tag
 {
     my($self, $tag, $attr) = @_;
 
     my $base = $self->{extractlink_base};
     my $links = $HTML::Tagset::linkElements{$tag};
     $links = [$links] unless ref $links;
 
     my @links;
     my $a;
     for $a (@$links) {
 	next unless exists $attr->{$a};
 	(my $link = $attr->{$a}) =~ s/^\s+//; $link =~ s/\s+$//; 
 	push(@links, $a, $base ? URI->new($link, $base)->abs($base) : $link);
     }
     return unless @links;
     $self->_found_link($tag, @links);
 }
 
 sub _found_link
 {
     my $self = shift;
     my $cb = $self->{extractlink_cb};
     if ($cb) {
 	&$cb(@_);
     } else {
 	push(@{$self->{'links'}}, [@_]);
     }
 }
 
 
 sub links
 {
     my $self = shift;
     exists($self->{'links'}) ? @{delete $self->{'links'}} : ();
 }
 
 sub parse_file
 {
     my $self = shift;
     delete $self->{'links'};
     $self->SUPER::parse_file(@_);
 }
 
 
 1;
### HTML/Parser.pm ###
 package HTML::Parser;
 
 
 use strict;
 use vars qw($VERSION @ISA);
 
 $VERSION = "3.71";
 
 require HTML::Entities;
 
 require XSLoader;
 XSLoader::load('HTML::Parser', $VERSION);
 
 sub new
 {
     my $class = shift;
     my $self = bless {}, $class;
     return $self->init(@_);
 }
 
 
 sub init
 {
     my $self = shift;
     $self->_alloc_pstate;
 
     my %arg = @_;
     my $api_version = delete $arg{api_version} || (@_ ? 3 : 2);
     if ($api_version >= 4) {
 	require Carp;
 	Carp::croak("API version $api_version not supported " .
 		    "by HTML::Parser $VERSION");
     }
 
     if ($api_version < 3) {
 	$self->handler(text    => "text",    "self,text,is_cdata");
 	$self->handler(end     => "end",     "self,tagname,text");
 	$self->handler(process => "process", "self,token0,text");
 	$self->handler(start   => "start",
 		                  "self,tagname,attr,attrseq,text");
 
 	$self->handler(comment =>
 		       sub {
 			   my($self, $tokens) = @_;
 			   for (@$tokens) {
 			       $self->comment($_);
 			   }
 		       }, "self,tokens");
 
 	$self->handler(declaration =>
 		       sub {
 			   my $self = shift;
 			   $self->declaration(substr($_[0], 2, -1));
 		       }, "self,text");
     }
 
     if (my $h = delete $arg{handlers}) {
 	$h = {@$h} if ref($h) eq "ARRAY";
 	while (my($event, $cb) = each %$h) {
 	    $self->handler($event => @$cb);
 	}
     }
 
     while (my($option, $val) = each %arg) {
 	if ($option =~ /^(\w+)_h$/) {
 	    $self->handler($1 => @$val);
 	}
         elsif ($option =~ /^(text|start|end|process|declaration|comment)$/) {
 	    require Carp;
 	    Carp::croak("Bad constructor option '$option'");
         }
 	else {
 	    $self->$option($val);
 	}
     }
 
     return $self;
 }
 
 
 sub parse_file
 {
     my($self, $file) = @_;
     my $opened;
     if (!ref($file) && ref(\$file) ne "GLOB") {
         local(*F);
         open(F, "<", $file) || return undef;
 	binmode(F);  
         $opened++;
         $file = *F;
     }
     my $chunk = '';
     while (read($file, $chunk, 512)) {
 	$self->parse($chunk) || last;
     }
     close($file) if $opened;
     $self->eof;
 }
 
 
 sub netscape_buggy_comment  
 {
     my $self = shift;
     require Carp;
     Carp::carp("netscape_buggy_comment() is deprecated.  " .
 	       "Please use the strict_comment() method instead");
     my $old = !$self->strict_comment;
     $self->strict_comment(!shift) if @_;
     return $old;
 }
 
 sub text { }
 *start       = \&text;
 *end         = \&text;
 *comment     = \&text;
 *declaration = \&text;
 *process     = \&text;
 
 1;
 
 __END__
 
 
### HTML/PullParser.pm ###
 package HTML::PullParser;
 
 require HTML::Parser;
 @ISA=qw(HTML::Parser);
 $VERSION = "3.57";
 
 use strict;
 use Carp ();
 
 sub new
 {
     my($class, %cnf) = @_;
 
     my %argspec;
     for (qw(start end text declaration comment process default)) {
 	my $tmp = delete $cnf{$_};
 	next unless defined $tmp;
 	$argspec{$_} = $tmp;
     }
     Carp::croak("Info not collected for any events")
 	  unless %argspec;
 
     my $file = delete $cnf{file};
     my $doc  = delete $cnf{doc};
     Carp::croak("Can't parse from both 'doc' and 'file' at the same time")
 	  if defined($file) && defined($doc);
     Carp::croak("No 'doc' or 'file' given to parse from")
 	  unless defined($file) || defined($doc);
 
     $cnf{api_version} = 3;
     my $self = $class->SUPER::new(%cnf);
 
     my $accum = $self->{pullparser_accum} = [];
     while (my($event, $argspec) = each %argspec) {
 	$self->SUPER::handler($event => $accum, $argspec);
     }
 
     if (defined $doc) {
 	$self->{pullparser_str_ref} = ref($doc) ? $doc : \$doc;
 	$self->{pullparser_str_pos} = 0;
     }
     else {
 	if (!ref($file) && ref(\$file) ne "GLOB") {
 	    require IO::File;
 	    $file = IO::File->new($file, "r") || return;
 	}
 
 	$self->{pullparser_file} = $file;
     }
     $self;
 }
 
 
 sub handler
 {
     Carp::croak("Can't set handlers for HTML::PullParser");
 }
 
 
 sub get_token
 {
     my $self = shift;
     while (!@{$self->{pullparser_accum}} && !$self->{pullparser_eof}) {
 	if (my $f = $self->{pullparser_file}) {
 	    my $buf;
 	    if (read($f, $buf, 512)) {
 		$self->parse($buf);
 	    } else {
 		$self->eof;
 		$self->{pullparser_eof}++;
 		delete $self->{pullparser_file};
 	    }
 	}
 	elsif (my $sref = $self->{pullparser_str_ref}) {
 	    my $pos = $self->{pullparser_str_pos};
 	    my $chunk = substr($$sref, $pos, 512);
 	    $self->parse($chunk);
 	    $pos += length($chunk);
 	    if ($pos < length($$sref)) {
 		$self->{pullparser_str_pos} = $pos;
 	    }
 	    else {
 		$self->eof;
 		$self->{pullparser_eof}++;
 		delete $self->{pullparser_str_ref};
 		delete $self->{pullparser_str_pos};
 	    }
 	}
 	else {
 	    die;
 	}
     }
     shift @{$self->{pullparser_accum}};
 }
 
 
 sub unget_token
 {
     my $self = shift;
     unshift @{$self->{pullparser_accum}}, @_;
     $self;
 }
 
 1;
 
 
 __END__
 
### HTML/Tagset.pm ###
 package HTML::Tagset;
 
 use strict;
 
 
 use vars qw( $VERSION );
 
 $VERSION = '3.20';
 
 
 use vars qw(
     $VERSION
     %emptyElement %optionalEndTag %linkElements %boolean_attr
     %isHeadElement %isBodyElement %isPhraseMarkup
     %is_Possible_Strict_P_Content
     %isHeadOrBodyElement
     %isList %isTableElement %isFormElement
     %isKnown %canTighten
     @p_closure_barriers
     %isCDATA_Parent
 );
 
 
 %emptyElement   = map {; $_ => 1 } qw(base link meta isindex
                                      img br hr wbr
                                      input area param
                                      embed bgsound spacer
                                      basefont col frame
                                      ~comment ~literal
                                      ~declaration ~pi
                                     );
 
 
 %optionalEndTag = map {; $_ => 1 } qw(p li dt dd); 
 
 
 %linkElements =
 (
  'a'       => ['href'],
  'applet'  => ['archive', 'codebase', 'code'],
  'area'    => ['href'],
  'base'    => ['href'],
  'bgsound' => ['src'],
  'blockquote' => ['cite'],
  'body'    => ['background'],
  'del'     => ['cite'],
  'embed'   => ['pluginspage', 'src'],
  'form'    => ['action'],
  'frame'   => ['src', 'longdesc'],
  'iframe'  => ['src', 'longdesc'],
  'ilayer'  => ['background'],
  'img'     => ['src', 'lowsrc', 'longdesc', 'usemap'],
  'input'   => ['src', 'usemap'],
  'ins'     => ['cite'],
  'isindex' => ['action'],
  'head'    => ['profile'],
  'layer'   => ['background', 'src'],
  'link'    => ['href'],
  'object'  => ['classid', 'codebase', 'data', 'archive', 'usemap'],
  'q'       => ['cite'],
  'script'  => ['src', 'for'],
  'table'   => ['background'],
  'td'      => ['background'],
  'th'      => ['background'],
  'tr'      => ['background'],
  'xmp'     => ['href'],
 );
 
 
 %boolean_attr = (
   'area'   => 'nohref',
   'dir'    => 'compact',
   'dl'     => 'compact',
   'hr'     => 'noshade',
   'img'    => 'ismap',
   'input'  => { 'checked' => 1, 'readonly' => 1, 'disabled' => 1 },
   'menu'   => 'compact',
   'ol'     => 'compact',
   'option' => 'selected',
   'select' => 'multiple',
   'td'     => 'nowrap',
   'th'     => 'nowrap',
   'ul'     => 'compact',
 );
 
 
 
 %isPhraseMarkup = map {; $_ => 1 } qw(
   span abbr acronym q sub sup
   cite code em kbd samp strong var dfn strike
   b i u s tt small big 
   a img br
   wbr nobr blink
   font basefont bdo
   spacer embed noembed
 );  
 
 
 
 %is_Possible_Strict_P_Content = (
  %isPhraseMarkup,
  %isFormElement,
  map {; $_ => 1} qw( object script map )
 );
 
 
 
 %isHeadElement = map {; $_ => 1 }
  qw(title base link meta isindex script style object bgsound);
 
 
 %isList         = map {; $_ => 1 } qw(ul ol dir menu);
 
 
 %isTableElement = map {; $_ => 1 }
  qw(tr td th thead tbody tfoot caption col colgroup);
 
 
 %isFormElement  = map {; $_ => 1 }
  qw(input select option optgroup textarea button label);
 
 
 %isBodyElement = map {; $_ => 1 } qw(
   h1 h2 h3 h4 h5 h6
   p div pre plaintext address blockquote
   xmp listing
   center
 
   multicol
   iframe ilayer nolayer
   bgsound
 
   hr
   ol ul dir menu li
   dl dt dd
   ins del
   
   fieldset legend
   
   map area
   applet param object
   isindex script noscript
   table
   center
   form
  ),
  keys %isFormElement,
  keys %isPhraseMarkup,   
  keys %isTableElement,
 ;
 
 
 
 %isHeadOrBodyElement = map {; $_ => 1 }
   qw(script isindex style object map area param noscript bgsound);
 
 
 
 %isKnown = (%isHeadElement, %isBodyElement,
   map{; $_=>1 }
    qw( head body html
        frame frameset noframes
        ~comment ~pi ~directive ~literal
 ));
 
 
 
 %canTighten = %isKnown;
 delete @canTighten{
   keys(%isPhraseMarkup), 'input', 'select',
   'xmp', 'listing', 'plaintext', 'pre',
 };
 @canTighten{'hr','br'} = (1,1);
 
 
 
 
 @p_closure_barriers = qw(
   li blockquote
   ul ol menu dir
   dl dt dd
   td th tr table caption
   div
  );
 
 
 
 %isCDATA_Parent = map {; $_ => 1 }
   qw(script style  xmp listing plaintext);
 
 
 
 
 
 1;
### HTML/TokeParser.pm ###
 package HTML::TokeParser;
 
 require HTML::PullParser;
 @ISA=qw(HTML::PullParser);
 $VERSION = "3.69";
 
 use strict;
 use Carp ();
 use HTML::Entities qw(decode_entities);
 use HTML::Tagset ();
 
 my %ARGS =
 (
  start       => "'S',tagname,attr,attrseq,text",
  end         => "'E',tagname,text",
  text        => "'T',text,is_cdata",
  process     => "'PI',token0,text",
  comment     => "'C',text",
  declaration => "'D',text",
 
  unbroken_text => 1,
 );
 
 
 sub new
 {
     my $class = shift;
     my %cnf;
 
     if (@_ == 1) {
 	my $type = (ref($_[0]) eq "SCALAR") ? "doc" : "file";
 	%cnf = ($type => $_[0]);
     }
     else {
 	unshift @_, (ref($_[0]) eq "SCALAR") ? "doc" : "file" if(scalar(@_) % 2 == 1);
 	%cnf = @_;
     }
 
     my $textify = delete $cnf{textify} || {img => "alt", applet => "alt"};
 
     my $self = $class->SUPER::new(%ARGS, %cnf) || return undef;
 
     $self->{textify} = $textify;
     $self;
 }
 
 
 sub get_tag
 {
     my $self = shift;
     my $token;
     while (1) {
 	$token = $self->get_token || return undef;
 	my $type = shift @$token;
 	next unless $type eq "S" || $type eq "E";
 	substr($token->[0], 0, 0) = "/" if $type eq "E";
 	return $token unless @_;
 	for (@_) {
 	    return $token if $token->[0] eq $_;
 	}
     }
 }
 
 
 sub _textify {
     my($self, $token) = @_;
     my $tag = $token->[1];
     return undef unless exists $self->{textify}{$tag};
 
     my $alt = $self->{textify}{$tag};
     my $text;
     if (ref($alt)) {
 	$text = &$alt(@$token);
     } else {
 	$text = $token->[2]{$alt || "alt"};
 	$text = "[\U$tag]" unless defined $text;
     }
     return $text;
 }
 
 
 sub get_text
 {
     my $self = shift;
     my @text;
     while (my $token = $self->get_token) {
 	my $type = $token->[0];
 	if ($type eq "T") {
 	    my $text = $token->[1];
 	    decode_entities($text) unless $token->[2];
 	    push(@text, $text);
 	} elsif ($type =~ /^[SE]$/) {
 	    my $tag = $token->[1];
 	    if ($type eq "S") {
 		if (defined(my $text = _textify($self, $token))) {
 		    push(@text, $text);
 		    next;
 		}
 	    } else {
 		$tag = "/$tag";
 	    }
 	    if (!@_ || grep $_ eq $tag, @_) {
 		 $self->unget_token($token);
 		 last;
 	    }
 	    push(@text, " ")
 		if $tag eq "br" || !$HTML::Tagset::isPhraseMarkup{$token->[1]};
 	}
     }
     join("", @text);
 }
 
 
 sub get_trimmed_text
 {
     my $self = shift;
     my $text = $self->get_text(@_);
     $text =~ s/^\s+//; $text =~ s/\s+$//; $text =~ s/\s+/ /g;
     $text;
 }
 
 sub get_phrase {
     my $self = shift;
     my @text;
     while (my $token = $self->get_token) {
 	my $type = $token->[0];
 	if ($type eq "T") {
 	    my $text = $token->[1];
 	    decode_entities($text) unless $token->[2];
 	    push(@text, $text);
 	} elsif ($type =~ /^[SE]$/) {
 	    my $tag = $token->[1];
 	    if ($type eq "S") {
 		if (defined(my $text = _textify($self, $token))) {
 		    push(@text, $text);
 		    next;
 		}
 	    }
 	    if (!$HTML::Tagset::isPhraseMarkup{$tag}) {
 		$self->unget_token($token);
 		last;
 	    }
 	    push(@text, " ") if $tag eq "br";
 	}
     }
     my $text = join("", @text);
     $text =~ s/^\s+//; $text =~ s/\s+$//; $text =~ s/\s+/ /g;
     $text;
 }
 
 1;
 
 
 __END__
 
### HTTP/Tiny.pm ###
 package HTTP::Tiny;
 use strict;
 use warnings;
 
 our $VERSION = '0.054';
 
 use Carp ();
 
 
 my @attributes;
 BEGIN {
     @attributes = qw(
         cookie_jar default_headers http_proxy https_proxy keep_alive
         local_address max_redirect max_size proxy no_proxy timeout
         SSL_options verify_SSL
     );
     my %persist_ok = map {; $_ => 1 } qw(
         cookie_jar default_headers max_redirect max_size
     );
     no strict 'refs';
     no warnings 'uninitialized';
     for my $accessor ( @attributes ) {
         *{$accessor} = sub {
             @_ > 1
                 ? do {
                     delete $_[0]->{handle} if !$persist_ok{$accessor} && $_[1] ne $_[0]->{$accessor};
                     $_[0]->{$accessor} = $_[1]
                 }
                 : $_[0]->{$accessor};
         };
     }
 }
 
 sub agent {
     my($self, $agent) = @_;
     if( @_ > 1 ){
         $self->{agent} =
             (defined $agent && $agent =~ / $/) ? $agent . $self->_agent : $agent;
     }
     return $self->{agent};
 }
 
 sub new {
     my($class, %args) = @_;
 
     my $self = {
         max_redirect => 5,
         timeout      => 60,
         keep_alive   => 1,
         verify_SSL   => $args{verify_SSL} || $args{verify_ssl} || 0, 
         no_proxy     => $ENV{no_proxy},
     };
 
     bless $self, $class;
 
     $class->_validate_cookie_jar( $args{cookie_jar} ) if $args{cookie_jar};
 
     for my $key ( @attributes ) {
         $self->{$key} = $args{$key} if exists $args{$key}
     }
 
     $self->agent( exists $args{agent} ? $args{agent} : $class->_agent );
 
     $self->_set_proxies;
 
     return $self;
 }
 
 sub _set_proxies {
     my ($self) = @_;
 
 
     if (! exists $self->{proxy} ) {
         $self->{proxy} = $ENV{all_proxy} || $ENV{ALL_PROXY};
     }
 
     if ( defined $self->{proxy} ) {
         $self->_split_proxy( 'generic proxy' => $self->{proxy} ); 
     }
     else {
         delete $self->{proxy};
     }
 
     if (! exists $self->{http_proxy} ) {
         local $ENV{HTTP_PROXY} if $ENV{REQUEST_METHOD};
         $self->{http_proxy} = $ENV{http_proxy} || $ENV{HTTP_PROXY} || $self->{proxy};
     }
 
     if ( defined $self->{http_proxy} ) {
         $self->_split_proxy( http_proxy => $self->{http_proxy} ); 
         $self->{_has_proxy}{http} = 1;
     }
     else {
         delete $self->{http_proxy};
     }
 
     if (! exists $self->{https_proxy} ) {
         $self->{https_proxy} = $ENV{https_proxy} || $ENV{HTTPS_PROXY} || $self->{proxy};
     }
 
     if ( $self->{https_proxy} ) {
         $self->_split_proxy( https_proxy => $self->{https_proxy} ); 
         $self->{_has_proxy}{https} = 1;
     }
     else {
         delete $self->{https_proxy};
     }
 
     unless ( ref $self->{no_proxy} eq 'ARRAY' ) {
         $self->{no_proxy} =
             (defined $self->{no_proxy}) ? [ split /\s*,\s*/, $self->{no_proxy} ] : [];
     }
 
     return;
 }
 
 
 for my $sub_name ( qw/get head put post delete/ ) {
     my $req_method = uc $sub_name;
     no strict 'refs';
     eval <<"HERE"; 
     sub $sub_name {
         my (\$self, \$url, \$args) = \@_;
         \@_ == 2 || (\@_ == 3 && ref \$args eq 'HASH')
         or Carp::croak(q/Usage: \$http->$sub_name(URL, [HASHREF])/ . "\n");
         return \$self->request('$req_method', \$url, \$args || {});
     }
 HERE
 }
 
 
 sub post_form {
     my ($self, $url, $data, $args) = @_;
     (@_ == 3 || @_ == 4 && ref $args eq 'HASH')
         or Carp::croak(q/Usage: $http->post_form(URL, DATAREF, [HASHREF])/ . "\n");
 
     my $headers = {};
     while ( my ($key, $value) = each %{$args->{headers} || {}} ) {
         $headers->{lc $key} = $value;
     }
     delete $args->{headers};
 
     return $self->request('POST', $url, {
             %$args,
             content => $self->www_form_urlencode($data),
             headers => {
                 %$headers,
                 'content-type' => 'application/x-www-form-urlencoded'
             },
         }
     );
 }
 
 
 sub mirror {
     my ($self, $url, $file, $args) = @_;
     @_ == 3 || (@_ == 4 && ref $args eq 'HASH')
       or Carp::croak(q/Usage: $http->mirror(URL, FILE, [HASHREF])/ . "\n");
     if ( -e $file and my $mtime = (stat($file))[9] ) {
         $args->{headers}{'if-modified-since'} ||= $self->_http_date($mtime);
     }
     my $tempfile = $file . int(rand(2**31));
 
     require Fcntl;
     sysopen my $fh, $tempfile, Fcntl::O_CREAT()|Fcntl::O_EXCL()|Fcntl::O_WRONLY()
        or Carp::croak(qq/Error: Could not create temporary file $tempfile for downloading: $!\n/);
     binmode $fh;
     $args->{data_callback} = sub { print {$fh} $_[0] };
     my $response = $self->request('GET', $url, $args);
     close $fh
         or Carp::croak(qq/Error: Caught error closing temporary file $tempfile: $!\n/);
 
     if ( $response->{success} ) {
         rename $tempfile, $file
             or Carp::croak(qq/Error replacing $file with $tempfile: $!\n/);
         my $lm = $response->{headers}{'last-modified'};
         if ( $lm and my $mtime = $self->_parse_http_date($lm) ) {
             utime $mtime, $mtime, $file;
         }
     }
     $response->{success} ||= $response->{status} eq '304';
     unlink $tempfile;
     return $response;
 }
 
 
 my %idempotent = map { $_ => 1 } qw/GET HEAD PUT DELETE OPTIONS TRACE/;
 
 sub request {
     my ($self, $method, $url, $args) = @_;
     @_ == 3 || (@_ == 4 && ref $args eq 'HASH')
       or Carp::croak(q/Usage: $http->request(METHOD, URL, [HASHREF])/ . "\n");
     $args ||= {}; 
 
     my $response;
     for ( 0 .. 1 ) {
         $response = eval { $self->_request($method, $url, $args) };
         last unless $@ && $idempotent{$method}
             && $@ =~ m{^(?:Socket closed|Unexpected end)};
     }
 
     if (my $e = $@) {
         if ( ref $e eq 'HASH' && exists $e->{status} ) {
             return $e;
         }
 
         $e = "$e";
         $response = {
             url     => $url,
             success => q{},
             status  => 599,
             reason  => 'Internal Exception',
             content => $e,
             headers => {
                 'content-type'   => 'text/plain',
                 'content-length' => length $e,
             }
         };
     }
     return $response;
 }
 
 
 sub www_form_urlencode {
     my ($self, $data) = @_;
     (@_ == 2 && ref $data)
         or Carp::croak(q/Usage: $http->www_form_urlencode(DATAREF)/ . "\n");
     (ref $data eq 'HASH' || ref $data eq 'ARRAY')
         or Carp::croak("form data must be a hash or array reference\n");
 
     my @params = ref $data eq 'HASH' ? %$data : @$data;
     @params % 2 == 0
         or Carp::croak("form data reference must have an even number of terms\n");
 
     my @terms;
     while( @params ) {
         my ($key, $value) = splice(@params, 0, 2);
         if ( ref $value eq 'ARRAY' ) {
             unshift @params, map { $key => $_ } @$value;
         }
         else {
             push @terms, join("=", map { $self->_uri_escape($_) } $key, $value);
         }
     }
 
     return join("&", (ref $data eq 'ARRAY') ? (@terms) : (sort @terms) );
 }
 
 
 my %DefaultPort = (
     http => 80,
     https => 443,
 );
 
 sub _agent {
     my $class = ref($_[0]) || $_[0];
     (my $default_agent = $class) =~ s{::}{-}g;
     return $default_agent . "/" . $class->VERSION;
 }
 
 sub _request {
     my ($self, $method, $url, $args) = @_;
 
     my ($scheme, $host, $port, $path_query, $auth) = $self->_split_url($url);
 
     my $request = {
         method    => $method,
         scheme    => $scheme,
         host      => $host,
         port      => $port,
         host_port => ($port == $DefaultPort{$scheme} ? $host : "$host:$port"),
         uri       => $path_query,
         headers   => {},
     };
 
     my $handle = delete $self->{handle};
     if ( $handle ) {
         unless ( $handle->can_reuse( $scheme, $host, $port ) ) {
             $handle->close;
             undef $handle;
         }
     }
     $handle ||= $self->_open_handle( $request, $scheme, $host, $port );
 
     $self->_prepare_headers_and_cb($request, $args, $url, $auth);
     $handle->write_request($request);
 
     my $response;
     do { $response = $handle->read_response_header }
         until (substr($response->{status},0,1) ne '1');
 
     $self->_update_cookie_jar( $url, $response ) if $self->{cookie_jar};
 
     if ( my @redir_args = $self->_maybe_redirect($request, $response, $args) ) {
         $handle->close;
         return $self->_request(@redir_args, $args);
     }
 
     my $known_message_length;
     if ($method eq 'HEAD' || $response->{status} =~ /^[23]04/) {
         $known_message_length = 1;
     }
     else {
         my $data_cb = $self->_prepare_data_cb($response, $args);
         $known_message_length = $handle->read_body($data_cb, $response);
     }
 
     if ( $self->{keep_alive}
         && $known_message_length
         && $response->{protocol} eq 'HTTP/1.1'
         && ($response->{headers}{connection} || '') ne 'close'
     ) {
         $self->{handle} = $handle;
     }
     else {
         $handle->close;
     }
 
     $response->{success} = substr( $response->{status}, 0, 1 ) eq '2';
     $response->{url} = $url;
     return $response;
 }
 
 sub _open_handle {
     my ($self, $request, $scheme, $host, $port) = @_;
 
     my $handle  = HTTP::Tiny::Handle->new(
         timeout         => $self->{timeout},
         SSL_options     => $self->{SSL_options},
         verify_SSL      => $self->{verify_SSL},
         local_address   => $self->{local_address},
         keep_alive      => $self->{keep_alive}
     );
 
     if ($self->{_has_proxy}{$scheme} && ! grep { $host =~ /\Q$_\E$/ } @{$self->{no_proxy}}) {
         return $self->_proxy_connect( $request, $handle );
     }
     else {
         return $handle->connect($scheme, $host, $port);
     }
 }
 
 sub _proxy_connect {
     my ($self, $request, $handle) = @_;
 
     my @proxy_vars;
     if ( $request->{scheme} eq 'https' ) {
         Carp::croak(qq{No https_proxy defined}) unless $self->{https_proxy};
         @proxy_vars = $self->_split_proxy( https_proxy => $self->{https_proxy} );
         if ( $proxy_vars[0] eq 'https' ) {
             Carp::croak(qq{Can't proxy https over https: $request->{uri} via $self->{https_proxy}});
         }
     }
     else {
         Carp::croak(qq{No http_proxy defined}) unless $self->{http_proxy};
         @proxy_vars = $self->_split_proxy( http_proxy => $self->{http_proxy} );
     }
 
     my ($p_scheme, $p_host, $p_port, $p_auth) = @proxy_vars;
 
     if ( length $p_auth && ! defined $request->{headers}{'proxy-authorization'} ) {
         $self->_add_basic_auth_header( $request, 'proxy-authorization' => $p_auth );
     }
 
     $handle->connect($p_scheme, $p_host, $p_port);
 
     if ($request->{scheme} eq 'https') {
         $self->_create_proxy_tunnel( $request, $handle );
     }
     else {
         $request->{uri} = "$request->{scheme}://$request->{host_port}$request->{uri}";
     }
 
     return $handle;
 }
 
 sub _split_proxy {
     my ($self, $type, $proxy) = @_;
 
     my ($scheme, $host, $port, $path_query, $auth) = eval { $self->_split_url($proxy) };
 
     unless(
         defined($scheme) && length($scheme) && length($host) && length($port)
         && $path_query eq '/'
     ) {
         Carp::croak(qq{$type URL must be in format http[s]://[auth@]<host>:<port>/\n});
     }
 
     return ($scheme, $host, $port, $auth);
 }
 
 sub _create_proxy_tunnel {
     my ($self, $request, $handle) = @_;
 
     $handle->_assert_ssl;
 
     my $agent = exists($request->{headers}{'user-agent'})
         ? $request->{headers}{'user-agent'} : $self->{agent};
 
     my $connect_request = {
         method    => 'CONNECT',
         uri       => "$request->{host}:$request->{port}",
         headers   => {
             host => "$request->{host}:$request->{port}",
             'user-agent' => $agent,
         }
     };
 
     if ( $request->{headers}{'proxy-authorization'} ) {
         $connect_request->{headers}{'proxy-authorization'} =
             delete $request->{headers}{'proxy-authorization'};
     }
 
     $handle->write_request($connect_request);
     my $response;
     do { $response = $handle->read_response_header }
         until (substr($response->{status},0,1) ne '1');
 
     unless (substr($response->{status},0,1) eq '2') {
         die $response;
     }
 
     $handle->start_ssl( $request->{host} );
 
     return;
 }
 
 sub _prepare_headers_and_cb {
     my ($self, $request, $args, $url, $auth) = @_;
 
     for ($self->{default_headers}, $args->{headers}) {
         next unless defined;
         while (my ($k, $v) = each %$_) {
             $request->{headers}{lc $k} = $v;
         }
     }
 
     if (exists $request->{headers}{'host'}) {
         die(qq/The 'Host' header must not be provided as header option\n/);
     }
 
     $request->{headers}{'host'}         = $request->{host_port};
     $request->{headers}{'user-agent'} ||= $self->{agent};
     $request->{headers}{'connection'}   = "close"
         unless $self->{keep_alive};
 
     if ( defined $args->{content} ) {
         if (ref $args->{content} eq 'CODE') {
             $request->{headers}{'content-type'} ||= "application/octet-stream";
             $request->{headers}{'transfer-encoding'} = 'chunked'
               unless $request->{headers}{'content-length'}
                   || $request->{headers}{'transfer-encoding'};
             $request->{cb} = $args->{content};
         }
         elsif ( length $args->{content} ) {
             my $content = $args->{content};
             if ( $] ge '5.008' ) {
                 utf8::downgrade($content, 1)
                     or die(qq/Wide character in request message body\n/);
             }
             $request->{headers}{'content-type'} ||= "application/octet-stream";
             $request->{headers}{'content-length'} = length $content
               unless $request->{headers}{'content-length'}
                   || $request->{headers}{'transfer-encoding'};
             $request->{cb} = sub { substr $content, 0, length $content, '' };
         }
         $request->{trailer_cb} = $args->{trailer_callback}
             if ref $args->{trailer_callback} eq 'CODE';
     }
 
     if ( $self->{cookie_jar} ) {
         my $cookies = $self->cookie_jar->cookie_header( $url );
         $request->{headers}{cookie} = $cookies if length $cookies;
     }
 
     if ( length $auth && ! defined $request->{headers}{authorization} ) {
         $self->_add_basic_auth_header( $request, 'authorization' => $auth );
     }
 
     return;
 }
 
 sub _add_basic_auth_header {
     my ($self, $request, $header, $auth) = @_;
     require MIME::Base64;
     $request->{headers}{$header} =
         "Basic " . MIME::Base64::encode_base64($auth, "");
     return;
 }
 
 sub _prepare_data_cb {
     my ($self, $response, $args) = @_;
     my $data_cb = $args->{data_callback};
     $response->{content} = '';
 
     if (!$data_cb || $response->{status} !~ /^2/) {
         if (defined $self->{max_size}) {
             $data_cb = sub {
                 $_[1]->{content} .= $_[0];
                 die(qq/Size of response body exceeds the maximum allowed of $self->{max_size}\n/)
                   if length $_[1]->{content} > $self->{max_size};
             };
         }
         else {
             $data_cb = sub { $_[1]->{content} .= $_[0] };
         }
     }
     return $data_cb;
 }
 
 sub _update_cookie_jar {
     my ($self, $url, $response) = @_;
 
     my $cookies = $response->{headers}->{'set-cookie'};
     return unless defined $cookies;
 
     my @cookies = ref $cookies ? @$cookies : $cookies;
 
     $self->cookie_jar->add( $url, $_ ) for @cookies;
 
     return;
 }
 
 sub _validate_cookie_jar {
     my ($class, $jar) = @_;
 
     for my $method ( qw/add cookie_header/ ) {
         Carp::croak(qq/Cookie jar must provide the '$method' method\n/)
             unless ref($jar) && ref($jar)->can($method);
     }
 
     return;
 }
 
 sub _maybe_redirect {
     my ($self, $request, $response, $args) = @_;
     my $headers = $response->{headers};
     my ($status, $method) = ($response->{status}, $request->{method});
     if (($status eq '303' or ($status =~ /^30[127]/ && $method =~ /^GET|HEAD$/))
         and $headers->{location}
         and ++$args->{redirects} <= $self->{max_redirect}
     ) {
         my $location = ($headers->{location} =~ /^\//)
             ? "$request->{scheme}://$request->{host_port}$headers->{location}"
             : $headers->{location} ;
         return (($status eq '303' ? 'GET' : $method), $location);
     }
     return;
 }
 
 sub _split_url {
     my $url = pop;
 
     my ($scheme, $host, $path_query) = $url =~ m<\A([^:/?#]+)://([^/?#]*)([^#]*)>
       or die(qq/Cannot parse URL: '$url'\n/);
 
     $scheme     = lc $scheme;
     $path_query = "/$path_query" unless $path_query =~ m<\A/>;
 
     my $auth = '';
     if ( (my $i = index $host, '@') != -1 ) {
         $auth = substr $host, 0, $i, ''; 
         substr $host, 0, 1, '';          
 
         $auth =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
     }
     my $port = $host =~ s/:(\d*)\z// && length $1 ? $1
              : $scheme eq 'http'                  ? 80
              : $scheme eq 'https'                 ? 443
              : undef;
 
     return ($scheme, (length $host ? lc $host : "localhost") , $port, $path_query, $auth);
 }
 
 my $DoW = "Sun|Mon|Tue|Wed|Thu|Fri|Sat";
 my $MoY = "Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec";
 sub _http_date {
     my ($sec, $min, $hour, $mday, $mon, $year, $wday) = gmtime($_[1]);
     return sprintf("%s, %02d %s %04d %02d:%02d:%02d GMT",
         substr($DoW,$wday*4,3),
         $mday, substr($MoY,$mon*4,3), $year+1900,
         $hour, $min, $sec
     );
 }
 
 sub _parse_http_date {
     my ($self, $str) = @_;
     require Time::Local;
     my @tl_parts;
     if ($str =~ /^[SMTWF][a-z]+, +(\d{1,2}) ($MoY) +(\d\d\d\d) +(\d\d):(\d\d):(\d\d) +GMT$/) {
         @tl_parts = ($6, $5, $4, $1, (index($MoY,$2)/4), $3);
     }
     elsif ($str =~ /^[SMTWF][a-z]+, +(\d\d)-($MoY)-(\d{2,4}) +(\d\d):(\d\d):(\d\d) +GMT$/ ) {
         @tl_parts = ($6, $5, $4, $1, (index($MoY,$2)/4), $3);
     }
     elsif ($str =~ /^[SMTWF][a-z]+ +($MoY) +(\d{1,2}) +(\d\d):(\d\d):(\d\d) +(?:[^0-9]+ +)?(\d\d\d\d)$/ ) {
         @tl_parts = ($5, $4, $3, $2, (index($MoY,$1)/4), $6);
     }
     return eval {
         my $t = @tl_parts ? Time::Local::timegm(@tl_parts) : -1;
         $t < 0 ? undef : $t;
     };
 }
 
 my %escapes = map { chr($_) => sprintf("%%%02X", $_) } 0..255;
 $escapes{' '}="+";
 my $unsafe_char = qr/[^A-Za-z0-9\-\._~]/;
 
 sub _uri_escape {
     my ($self, $str) = @_;
     if ( $] ge '5.008' ) {
         utf8::encode($str);
     }
     else {
         $str = pack("U*", unpack("C*", $str)) 
             if ( length $str == do { use bytes; length $str } );
         $str = pack("C*", unpack("C*", $str)); 
     }
     $str =~ s/($unsafe_char)/$escapes{$1}/ge;
     return $str;
 }
 
 package
     HTTP::Tiny::Handle; 
 use strict;
 use warnings;
 
 use Errno      qw[EINTR EPIPE];
 use IO::Socket qw[SOCK_STREAM];
 
 my $SOCKET_CLASS =
     $ENV{PERL_HTTP_TINY_IPV4_ONLY} ? 'IO::Socket::INET' :
     eval { require IO::Socket::IP; IO::Socket::IP->VERSION(0.25) } ? 'IO::Socket::IP' :
     'IO::Socket::INET';
 
 sub BUFSIZE () { 32768 } 
 
 my $Printable = sub {
     local $_ = shift;
     s/\r/\\r/g;
     s/\n/\\n/g;
     s/\t/\\t/g;
     s/([^\x20-\x7E])/sprintf('\\x%.2X', ord($1))/ge;
     $_;
 };
 
 my $Token = qr/[\x21\x23-\x27\x2A\x2B\x2D\x2E\x30-\x39\x41-\x5A\x5E-\x7A\x7C\x7E]/;
 
 sub new {
     my ($class, %args) = @_;
     return bless {
         rbuf             => '',
         timeout          => 60,
         max_line_size    => 16384,
         max_header_lines => 64,
         verify_SSL       => 0,
         SSL_options      => {},
         %args
     }, $class;
 }
 
 sub connect {
     @_ == 4 || die(q/Usage: $handle->connect(scheme, host, port)/ . "\n");
     my ($self, $scheme, $host, $port) = @_;
 
     if ( $scheme eq 'https' ) {
         $self->_assert_ssl;
     }
     elsif ( $scheme ne 'http' ) {
       die(qq/Unsupported URL scheme '$scheme'\n/);
     }
     $self->{fh} = $SOCKET_CLASS->new(
         PeerHost  => $host,
         PeerPort  => $port,
         $self->{local_address} ?
             ( LocalAddr => $self->{local_address} ) : (),
         Proto     => 'tcp',
         Type      => SOCK_STREAM,
         Timeout   => $self->{timeout},
         KeepAlive => !!$self->{keep_alive}
     ) or die(qq/Could not connect to '$host:$port': $@\n/);
 
     binmode($self->{fh})
       or die(qq/Could not binmode() socket: '$!'\n/);
 
     $self->start_ssl($host) if $scheme eq 'https';
 
     $self->{scheme} = $scheme;
     $self->{host} = $host;
     $self->{port} = $port;
     $self->{pid} = $$;
     $self->{tid} = _get_tid();
 
     return $self;
 }
 
 sub start_ssl {
     my ($self, $host) = @_;
 
     if ( ref($self->{fh}) eq 'IO::Socket::SSL' ) {
         unless ( $self->{fh}->stop_SSL ) {
             my $ssl_err = IO::Socket::SSL->errstr;
             die(qq/Error halting prior SSL connection: $ssl_err/);
         }
     }
 
     my $ssl_args = $self->_ssl_args($host);
     IO::Socket::SSL->start_SSL(
         $self->{fh},
         %$ssl_args,
         SSL_create_ctx_callback => sub {
             my $ctx = shift;
             Net::SSLeay::CTX_set_mode($ctx, Net::SSLeay::MODE_AUTO_RETRY());
         },
     );
 
     unless ( ref($self->{fh}) eq 'IO::Socket::SSL' ) {
         my $ssl_err = IO::Socket::SSL->errstr;
         die(qq/SSL connection failed for $host: $ssl_err\n/);
     }
 }
 
 sub close {
     @_ == 1 || die(q/Usage: $handle->close()/ . "\n");
     my ($self) = @_;
     CORE::close($self->{fh})
       or die(qq/Could not close socket: '$!'\n/);
 }
 
 sub write {
     @_ == 2 || die(q/Usage: $handle->write(buf)/ . "\n");
     my ($self, $buf) = @_;
 
     if ( $] ge '5.008' ) {
         utf8::downgrade($buf, 1)
             or die(qq/Wide character in write()\n/);
     }
 
     my $len = length $buf;
     my $off = 0;
 
     local $SIG{PIPE} = 'IGNORE';
 
     while () {
         $self->can_write
           or die(qq/Timed out while waiting for socket to become ready for writing\n/);
         my $r = syswrite($self->{fh}, $buf, $len, $off);
         if (defined $r) {
             $len -= $r;
             $off += $r;
             last unless $len > 0;
         }
         elsif ($! == EPIPE) {
             die(qq/Socket closed by remote server: $!\n/);
         }
         elsif ($! != EINTR) {
             if ($self->{fh}->can('errstr')){
                 my $err = $self->{fh}->errstr();
                 die (qq/Could not write to SSL socket: '$err'\n /);
             }
             else {
                 die(qq/Could not write to socket: '$!'\n/);
             }
 
         }
     }
     return $off;
 }
 
 sub read {
     @_ == 2 || @_ == 3 || die(q/Usage: $handle->read(len [, allow_partial])/ . "\n");
     my ($self, $len, $allow_partial) = @_;
 
     my $buf  = '';
     my $got = length $self->{rbuf};
 
     if ($got) {
         my $take = ($got < $len) ? $got : $len;
         $buf  = substr($self->{rbuf}, 0, $take, '');
         $len -= $take;
     }
 
     while ($len > 0) {
         $self->can_read
           or die(q/Timed out while waiting for socket to become ready for reading/ . "\n");
         my $r = sysread($self->{fh}, $buf, $len, length $buf);
         if (defined $r) {
             last unless $r;
             $len -= $r;
         }
         elsif ($! != EINTR) {
             if ($self->{fh}->can('errstr')){
                 my $err = $self->{fh}->errstr();
                 die (qq/Could not read from SSL socket: '$err'\n /);
             }
             else {
                 die(qq/Could not read from socket: '$!'\n/);
             }
         }
     }
     if ($len && !$allow_partial) {
         die(qq/Unexpected end of stream\n/);
     }
     return $buf;
 }
 
 sub readline {
     @_ == 1 || die(q/Usage: $handle->readline()/ . "\n");
     my ($self) = @_;
 
     while () {
         if ($self->{rbuf} =~ s/\A ([^\x0D\x0A]* \x0D?\x0A)//x) {
             return $1;
         }
         if (length $self->{rbuf} >= $self->{max_line_size}) {
             die(qq/Line size exceeds the maximum allowed size of $self->{max_line_size}\n/);
         }
         $self->can_read
           or die(qq/Timed out while waiting for socket to become ready for reading\n/);
         my $r = sysread($self->{fh}, $self->{rbuf}, BUFSIZE, length $self->{rbuf});
         if (defined $r) {
             last unless $r;
         }
         elsif ($! != EINTR) {
             if ($self->{fh}->can('errstr')){
                 my $err = $self->{fh}->errstr();
                 die (qq/Could not read from SSL socket: '$err'\n /);
             }
             else {
                 die(qq/Could not read from socket: '$!'\n/);
             }
         }
     }
     die(qq/Unexpected end of stream while looking for line\n/);
 }
 
 sub read_header_lines {
     @_ == 1 || @_ == 2 || die(q/Usage: $handle->read_header_lines([headers])/ . "\n");
     my ($self, $headers) = @_;
     $headers ||= {};
     my $lines   = 0;
     my $val;
 
     while () {
          my $line = $self->readline;
 
          if (++$lines >= $self->{max_header_lines}) {
              die(qq/Header lines exceeds maximum number allowed of $self->{max_header_lines}\n/);
          }
          elsif ($line =~ /\A ([^\x00-\x1F\x7F:]+) : [\x09\x20]* ([^\x0D\x0A]*)/x) {
              my ($field_name) = lc $1;
              if (exists $headers->{$field_name}) {
                  for ($headers->{$field_name}) {
                      $_ = [$_] unless ref $_ eq "ARRAY";
                      push @$_, $2;
                      $val = \$_->[-1];
                  }
              }
              else {
                  $val = \($headers->{$field_name} = $2);
              }
          }
          elsif ($line =~ /\A [\x09\x20]+ ([^\x0D\x0A]*)/x) {
              $val
                or die(qq/Unexpected header continuation line\n/);
              next unless length $1;
              $$val .= ' ' if length $$val;
              $$val .= $1;
          }
          elsif ($line =~ /\A \x0D?\x0A \z/x) {
             last;
          }
          else {
             die(q/Malformed header line: / . $Printable->($line) . "\n");
          }
     }
     return $headers;
 }
 
 sub write_request {
     @_ == 2 || die(q/Usage: $handle->write_request(request)/ . "\n");
     my($self, $request) = @_;
     $self->write_request_header(@{$request}{qw/method uri headers/});
     $self->write_body($request) if $request->{cb};
     return;
 }
 
 my %HeaderCase = (
     'content-md5'      => 'Content-MD5',
     'etag'             => 'ETag',
     'te'               => 'TE',
     'www-authenticate' => 'WWW-Authenticate',
     'x-xss-protection' => 'X-XSS-Protection',
 );
 
 sub write_header_lines {
     (@_ == 2 || @_ == 3 && ref $_[1] eq 'HASH') || die(q/Usage: $handle->write_header_lines(headers[,prefix])/ . "\n");
     my($self, $headers, $prefix_data) = @_;
 
     my $buf = (defined $prefix_data ? $prefix_data : '');
     while (my ($k, $v) = each %$headers) {
         my $field_name = lc $k;
         if (exists $HeaderCase{$field_name}) {
             $field_name = $HeaderCase{$field_name};
         }
         else {
             $field_name =~ /\A $Token+ \z/xo
               or die(q/Invalid HTTP header field name: / . $Printable->($field_name) . "\n");
             $field_name =~ s/\b(\w)/\u$1/g;
             $HeaderCase{lc $field_name} = $field_name;
         }
         for (ref $v eq 'ARRAY' ? @$v : $v) {
             $_ = '' unless defined $_;
             $buf .= "$field_name: $_\x0D\x0A";
         }
     }
     $buf .= "\x0D\x0A";
     return $self->write($buf);
 }
 
 sub read_body {
     @_ == 3 || die(q/Usage: $handle->read_body(callback, response)/ . "\n");
     my ($self, $cb, $response) = @_;
     my $te = $response->{headers}{'transfer-encoding'} || '';
     my $chunked = grep { /chunked/i } ( ref $te eq 'ARRAY' ? @$te : $te ) ;
     return $chunked
         ? $self->read_chunked_body($cb, $response)
         : $self->read_content_body($cb, $response);
 }
 
 sub write_body {
     @_ == 2 || die(q/Usage: $handle->write_body(request)/ . "\n");
     my ($self, $request) = @_;
     if ($request->{headers}{'content-length'}) {
         return $self->write_content_body($request);
     }
     else {
         return $self->write_chunked_body($request);
     }
 }
 
 sub read_content_body {
     @_ == 3 || @_ == 4 || die(q/Usage: $handle->read_content_body(callback, response, [read_length])/ . "\n");
     my ($self, $cb, $response, $content_length) = @_;
     $content_length ||= $response->{headers}{'content-length'};
 
     if ( defined $content_length ) {
         my $len = $content_length;
         while ($len > 0) {
             my $read = ($len > BUFSIZE) ? BUFSIZE : $len;
             $cb->($self->read($read, 0), $response);
             $len -= $read;
         }
         return length($self->{rbuf}) == 0;
     }
 
     my $chunk;
     $cb->($chunk, $response) while length( $chunk = $self->read(BUFSIZE, 1) );
 
     return;
 }
 
 sub write_content_body {
     @_ == 2 || die(q/Usage: $handle->write_content_body(request)/ . "\n");
     my ($self, $request) = @_;
 
     my ($len, $content_length) = (0, $request->{headers}{'content-length'});
     while () {
         my $data = $request->{cb}->();
 
         defined $data && length $data
           or last;
 
         if ( $] ge '5.008' ) {
             utf8::downgrade($data, 1)
                 or die(qq/Wide character in write_content()\n/);
         }
 
         $len += $self->write($data);
     }
 
     $len == $content_length
       or die(qq/Content-Length mismatch (got: $len expected: $content_length)\n/);
 
     return $len;
 }
 
 sub read_chunked_body {
     @_ == 3 || die(q/Usage: $handle->read_chunked_body(callback, $response)/ . "\n");
     my ($self, $cb, $response) = @_;
 
     while () {
         my $head = $self->readline;
 
         $head =~ /\A ([A-Fa-f0-9]+)/x
           or die(q/Malformed chunk head: / . $Printable->($head) . "\n");
 
         my $len = hex($1)
           or last;
 
         $self->read_content_body($cb, $response, $len);
 
         $self->read(2) eq "\x0D\x0A"
           or die(qq/Malformed chunk: missing CRLF after chunk data\n/);
     }
     $self->read_header_lines($response->{headers});
     return 1;
 }
 
 sub write_chunked_body {
     @_ == 2 || die(q/Usage: $handle->write_chunked_body(request)/ . "\n");
     my ($self, $request) = @_;
 
     my $len = 0;
     while () {
         my $data = $request->{cb}->();
 
         defined $data && length $data
           or last;
 
         if ( $] ge '5.008' ) {
             utf8::downgrade($data, 1)
                 or die(qq/Wide character in write_chunked_body()\n/);
         }
 
         $len += length $data;
 
         my $chunk  = sprintf '%X', length $data;
            $chunk .= "\x0D\x0A";
            $chunk .= $data;
            $chunk .= "\x0D\x0A";
 
         $self->write($chunk);
     }
     $self->write("0\x0D\x0A");
     $self->write_header_lines($request->{trailer_cb}->())
         if ref $request->{trailer_cb} eq 'CODE';
     return $len;
 }
 
 sub read_response_header {
     @_ == 1 || die(q/Usage: $handle->read_response_header()/ . "\n");
     my ($self) = @_;
 
     my $line = $self->readline;
 
     $line =~ /\A (HTTP\/(0*\d+\.0*\d+)) [\x09\x20]+ ([0-9]{3}) [\x09\x20]+ ([^\x0D\x0A]*) \x0D?\x0A/x
       or die(q/Malformed Status-Line: / . $Printable->($line). "\n");
 
     my ($protocol, $version, $status, $reason) = ($1, $2, $3, $4);
 
     die (qq/Unsupported HTTP protocol: $protocol\n/)
         unless $version =~ /0*1\.0*[01]/;
 
     return {
         status       => $status,
         reason       => $reason,
         headers      => $self->read_header_lines,
         protocol     => $protocol,
     };
 }
 
 sub write_request_header {
     @_ == 4 || die(q/Usage: $handle->write_request_header(method, request_uri, headers)/ . "\n");
     my ($self, $method, $request_uri, $headers) = @_;
 
     return $self->write_header_lines($headers, "$method $request_uri HTTP/1.1\x0D\x0A");
 }
 
 sub _do_timeout {
     my ($self, $type, $timeout) = @_;
     $timeout = $self->{timeout}
         unless defined $timeout && $timeout >= 0;
 
     my $fd = fileno $self->{fh};
     defined $fd && $fd >= 0
       or die(qq/select(2): 'Bad file descriptor'\n/);
 
     my $initial = time;
     my $pending = $timeout;
     my $nfound;
 
     vec(my $fdset = '', $fd, 1) = 1;
 
     while () {
         $nfound = ($type eq 'read')
             ? select($fdset, undef, undef, $pending)
             : select(undef, $fdset, undef, $pending) ;
         if ($nfound == -1) {
             $! == EINTR
               or die(qq/select(2): '$!'\n/);
             redo if !$timeout || ($pending = $timeout - (time - $initial)) > 0;
             $nfound = 0;
         }
         last;
     }
     $! = 0;
     return $nfound;
 }
 
 sub can_read {
     @_ == 1 || @_ == 2 || die(q/Usage: $handle->can_read([timeout])/ . "\n");
     my $self = shift;
     if ( ref($self->{fh}) eq 'IO::Socket::SSL' ) {
         return 1 if $self->{fh}->pending;
     }
     return $self->_do_timeout('read', @_)
 }
 
 sub can_write {
     @_ == 1 || @_ == 2 || die(q/Usage: $handle->can_write([timeout])/ . "\n");
     my $self = shift;
     return $self->_do_timeout('write', @_)
 }
 
 sub _assert_ssl {
     die(qq/IO::Socket::SSL 1.42 must be installed for https support\n/)
         unless eval {require IO::Socket::SSL; IO::Socket::SSL->VERSION(1.42)};
     die(qq/Net::SSLeay 1.49 must be installed for https support\n/)
         unless eval {require Net::SSLeay; Net::SSLeay->VERSION(1.49)};
 }
 
 sub can_reuse {
     my ($self,$scheme,$host,$port) = @_;
     return 0 if
         $self->{pid} != $$
         || $self->{tid} != _get_tid()
         || length($self->{rbuf})
         || $scheme ne $self->{scheme}
         || $host ne $self->{host}
         || $port ne $self->{port}
         || eval { $self->can_read(0) }
         || $@ ;
         return 1;
 }
 
 sub _find_CA_file {
     my $self = shift();
 
     return $self->{SSL_options}->{SSL_ca_file}
         if $self->{SSL_options}->{SSL_ca_file} and -e $self->{SSL_options}->{SSL_ca_file};
 
     return Mozilla::CA::SSL_ca_file()
         if eval { require Mozilla::CA };
 
     foreach my $ca_bundle (
         "/etc/ssl/certs/ca-certificates.crt",     
         "/etc/pki/tls/certs/ca-bundle.crt",       
         "/etc/ssl/ca-bundle.pem",                 
         "/etc/openssl/certs/ca-certificates.crt", 
         "/etc/ssl/cert.pem",                      
         "/usr/local/share/certs/ca-root-nss.crt", 
         "/etc/pki/tls/cacert.pem",                
         "/etc/certs/ca-certificates.crt",         
     ) {
         return $ca_bundle if -e $ca_bundle;
     }
 
     die qq/Couldn't find a CA bundle with which to verify the SSL certificate.\n/
       . qq/Try installing Mozilla::CA from CPAN\n/;
 }
 
 sub _get_tid {
     no warnings 'reserved'; 
     return threads->can("tid") ? threads->tid : 0;
 }
 
 sub _ssl_args {
     my ($self, $host) = @_;
 
     my %ssl_args;
 
     if ( Net::SSLeay::OPENSSL_VERSION_NUMBER() >= 0x01000000 ) {
         $ssl_args{SSL_hostname} = $host,          
     }
 
     if ($self->{verify_SSL}) {
         $ssl_args{SSL_verifycn_scheme}  = 'http'; 
         $ssl_args{SSL_verifycn_name}    = $host;  
         $ssl_args{SSL_verify_mode}      = 0x01;   
         $ssl_args{SSL_ca_file}          = $self->_find_CA_file;
     }
     else {
         $ssl_args{SSL_verifycn_scheme}  = 'none'; 
         $ssl_args{SSL_verify_mode}      = 0x00;   
     }
 
     for my $k ( keys %{$self->{SSL_options}} ) {
         $ssl_args{$k} = $self->{SSL_options}{$k} if $k =~ m/^SSL_/;
     }
 
     return \%ssl_args;
 }
 
 1;
 
 __END__
 
### HTTP/Tiny/UNIX.pm ###
 package HTTP::Tiny::UNIX;
 
 use 5.010001;
 use strict;
 use warnings;
 
 our $DATE = '2014-07-04'; 
 our $VERSION = '0.04'; 
 
 
 use parent qw(HTTP::Tiny);
 
 use IO::Socket::UNIX;
 
 sub _split_url {
     my ($self, $url) = @_;
 
     if ($url =~ m<\A[^:/?#]+://>) {
         $self->{_unix} = 0;
         return $self->SUPER::_split_url($url);
     }
 
     my ($scheme, $sock_path, $path_query) =
         $url =~ m<\A(\w+):(.+?)/(/[^#]*)>
             or die "Cannot parse HTTP-over-Unix URL: '$url'\n";
 
     $self->{_unix} = 1;
     $self->{_path_query} = $path_query;
 
     $scheme = lc $scheme;
     die "Only http scheme is supported\n" unless $scheme eq 'http';
 
     return  ($scheme, $sock_path, -1,    $path_query, '');
 }
 
 sub _open_handle {
     my ($self, $request, $scheme, $host, $port) = @_;
 
     return $self->SUPER::_open_handle($request, $scheme, $host, $port)
         unless $self->{_unix};
 
     my $handle = HTTP::Tiny::Handle::UNIX->new(
         timeout => $self->{timeout},
     );
 
     $handle->connect($scheme, $host, $port, $self);
 }
 
 package
     HTTP::Tiny::Handle::UNIX;
 
 use parent -norequire, 'HTTP::Tiny::Handle';
 
 use IO::Socket;
 
 sub connect {
     my ($self, $scheme, $host, $port, $tiny) = @_;
 
     my $path = $host;
 
     local($^W) = 0;
     my $sock = IO::Socket::UNIX->new(
         Peer    => $path,
         Type    => SOCK_STREAM,
         Timeout => $self->{timeout},
         Host    => 'localhost',
     );
 
     unless ($sock) {
         $@ =~ s/^.*?: //;
         die "Can't open Unix socket $path\: $@";
     }
 
     eval { $sock->blocking(0); };
 
     $self->{fh} = $sock;
 
     $self->{scheme} = $scheme;
     $self->{host} = $host;
     $self->{port} = $port;
     $self->{_unix} = 1;
     $self->{_tiny} = $tiny;
     $self;
 }
 
 sub write_request_header {
     my ($self, $method, $request_uri, $headers) = @_;
 
     return $self->write_request_header($method, $request_uri, $headers)
         unless $self->{_unix};
 
     return $self->write_header_lines($headers, "$method $self->{_tiny}{_path_query} HTTP/1.1\x0D\x0A");
 }
 
 1;
 
 __END__
 
### IO/Socket/UNIX/Util.pm ###
 package IO::Socket::UNIX::Util;
 
 our $DATE = '2014-12-05'; 
 our $VERSION = '0.05'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use IO::Socket::UNIX;
 use POSIX qw(locale_h);
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        create_unix_socket
                        create_unix_stream_socket
                        create_unix_datagram_socket
                );
 
 sub create_unix_socket {
     my ($path, $mode, $opts) = @_;
 
     $opts //= {};
 
     my $old_locale = setlocale(LC_ALL);
 
     my $sock;
 
     setlocale(LC_ALL, "C"); 
     {
         $sock = IO::Socket::UNIX->new(
             Type => SOCK_STREAM,
             Peer => $path,
             %$opts,
         );
         my $err = $@ unless $sock;
         if ($sock) {
             die "Some process is already listening on $path, aborting";
         } elsif ($err =~ /^connect: permission denied/i) {
             die "Cannot access $path, aborting";
         } elsif (1) { 
             unlink $path;
         } elsif ($err !~ /^connect: no such file/i) {
             die "Cannot bind to $path: $err";
         }
     }
     setlocale(LC_ALL, $old_locale);
 
 
     $sock = IO::Socket::UNIX->new(
         Type   => SOCK_STREAM,
         Local  => $path,
         Listen => 1,
         %$opts,
     );
     die "Can't create listening Unix socket: $@" unless $sock;
 
     if (defined $mode) {
         warn "Can't chmod $path: $!" unless chmod($mode, $path);
     }
 
     $sock;
 }
 
 sub create_unix_stream_socket {
     my ($path, $mode, $opts) = @_;
     $opts //= {};
     create_unix_socket($path, $mode, {Type=>SOCK_STREAM, %$opts});
 }
 
 sub create_unix_datagram_socket {
     my ($path, $mode, $opts) = @_;
     $opts //= {};
     create_unix_socket($path, $mode, {Type=>SOCK_DGRAM, %$opts});
 }
 
 1;
 
 __END__
 
### JSON.pm ###
 package JSON;
 
 
 use strict;
 use Carp ();
 use base qw(Exporter);
 @JSON::EXPORT = qw(from_json to_json jsonToObj objToJson encode_json decode_json);
 
 BEGIN {
     $JSON::VERSION = '2.90';
     $JSON::DEBUG   = 0 unless (defined $JSON::DEBUG);
     $JSON::DEBUG   = $ENV{ PERL_JSON_DEBUG } if exists $ENV{ PERL_JSON_DEBUG };
 }
 
 my $Module_XS  = 'JSON::XS';
 my $Module_PP  = 'JSON::PP';
 my $Module_bp  = 'JSON::backportPP'; 
 my $PP_Version = '2.27203';
 my $XS_Version = '2.34';
 
 
 
 my @PublicMethods = qw/
     ascii latin1 utf8 pretty indent space_before space_after relaxed canonical allow_nonref 
     allow_blessed convert_blessed filter_json_object filter_json_single_key_object 
     shrink max_depth max_size encode decode decode_prefix allow_unknown
 /;
 
 my @Properties = qw/
     ascii latin1 utf8 indent space_before space_after relaxed canonical allow_nonref
     allow_blessed convert_blessed shrink max_depth max_size allow_unknown
 /;
 
 my @XSOnlyMethods = qw/allow_tags/; 
 
 my @PPOnlyMethods = qw/
     indent_length sort_by
     allow_singlequote allow_bignum loose allow_barekey escape_slash as_nonblessed
 /; 
 
 
 my $_INSTALL_DONT_DIE  = 1; 
 my $_INSTALL_ONLY      = 2; 
 my $_ALLOW_UNSUPPORTED = 0;
 my $_UNIV_CONV_BLESSED = 0;
 my $_USSING_bpPP       = 0;
 
 
 
 unless ($JSON::Backend) {
     $JSON::DEBUG and  Carp::carp("Check used worker module...");
 
     my $backend = exists $ENV{PERL_JSON_BACKEND} ? $ENV{PERL_JSON_BACKEND} : 1;
 
     if ($backend eq '1' or $backend =~ /JSON::XS\s*,\s*JSON::PP/) {
         _load_xs($_INSTALL_DONT_DIE) or _load_pp();
     }
     elsif ($backend eq '0' or $backend eq 'JSON::PP') {
         _load_pp();
     }
     elsif ($backend eq '2' or $backend eq 'JSON::XS') {
         _load_xs();
     }
     elsif ($backend eq 'JSON::backportPP') {
         $_USSING_bpPP = 1;
         _load_pp();
     }
     else {
         Carp::croak "The value of environmental variable 'PERL_JSON_BACKEND' is invalid.";
     }
 }
 
 
 sub import {
     my $pkg = shift;
     my @what_to_export;
     my $no_export;
 
     for my $tag (@_) {
         if ($tag eq '-support_by_pp') {
             if (!$_ALLOW_UNSUPPORTED++) {
                 JSON::Backend::XS
                     ->support_by_pp(@PPOnlyMethods) if ($JSON::Backend eq $Module_XS);
             }
             next;
         }
         elsif ($tag eq '-no_export') {
             $no_export++, next;
         }
         elsif ( $tag eq '-convert_blessed_universally' ) {
             eval q|
                 require B;
                 *UNIVERSAL::TO_JSON = sub {
                     my $b_obj = B::svref_2object( $_[0] );
                     return    $b_obj->isa('B::HV') ? { %{ $_[0] } }
                             : $b_obj->isa('B::AV') ? [ @{ $_[0] } ]
                             : undef
                             ;
                 }
             | if ( !$_UNIV_CONV_BLESSED++ );
             next;
         }
         push @what_to_export, $tag;
     }
 
     return if ($no_export);
 
     __PACKAGE__->export_to_level(1, $pkg, @what_to_export);
 }
 
 
 
 sub jsonToObj {
     my $alternative = 'from_json';
     if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) {
         shift @_; $alternative = 'decode';
     }
     Carp::carp "'jsonToObj' will be obsoleted. Please use '$alternative' instead.";
     return JSON::from_json(@_);
 };
 
 sub objToJson {
     my $alternative = 'to_json';
     if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) {
         shift @_; $alternative = 'encode';
     }
     Carp::carp "'objToJson' will be obsoleted. Please use '$alternative' instead.";
     JSON::to_json(@_);
 };
 
 
 
 sub to_json ($@) {
     if (
         ref($_[0]) eq 'JSON'
         or (@_ > 2 and $_[0] eq 'JSON')
     ) {
         Carp::croak "to_json should not be called as a method.";
     }
     my $json = JSON->new;
 
     if (@_ == 2 and ref $_[1] eq 'HASH') {
         my $opt  = $_[1];
         for my $method (keys %$opt) {
             $json->$method( $opt->{$method} );
         }
     }
 
     $json->encode($_[0]);
 }
 
 
 sub from_json ($@) {
     if ( ref($_[0]) eq 'JSON' or $_[0] eq 'JSON' ) {
         Carp::croak "from_json should not be called as a method.";
     }
     my $json = JSON->new;
 
     if (@_ == 2 and ref $_[1] eq 'HASH') {
         my $opt  = $_[1];
         for my $method (keys %$opt) {
             $json->$method( $opt->{$method} );
         }
     }
 
     return $json->decode( $_[0] );
 }
 
 
 
 sub true  { $JSON::true  }
 
 sub false { $JSON::false }
 
 sub null  { undef; }
 
 
 sub require_xs_version { $XS_Version; }
 
 sub backend {
     my $proto = shift;
     $JSON::Backend;
 }
 
 
 
 sub is_xs {
     return $_[0]->backend eq $Module_XS;
 }
 
 
 sub is_pp {
     return not $_[0]->is_xs;
 }
 
 
 sub pureperl_only_methods { @PPOnlyMethods; }
 
 
 sub property {
     my ($self, $name, $value) = @_;
 
     if (@_ == 1) {
         my %props;
         for $name (@Properties) {
             my $method = 'get_' . $name;
             if ($name eq 'max_size') {
                 my $value = $self->$method();
                 $props{$name} = $value == 1 ? 0 : $value;
                 next;
             }
             $props{$name} = $self->$method();
         }
         return \%props;
     }
     elsif (@_ > 3) {
         Carp::croak('property() can take only the option within 2 arguments.');
     }
     elsif (@_ == 2) {
         if ( my $method = $self->can('get_' . $name) ) {
             if ($name eq 'max_size') {
                 my $value = $self->$method();
                 return $value == 1 ? 0 : $value;
             }
             $self->$method();
         }
     }
     else {
         $self->$name($value);
     }
 
 }
 
 
 
 
 sub _load_xs {
     my $opt = shift;
 
     $JSON::DEBUG and Carp::carp "Load $Module_XS.";
 
     JSON::Boolean::_overrride_overload($Module_XS);
     JSON::Boolean::_overrride_overload($Module_PP);
 
     eval qq|
         use $Module_XS $XS_Version ();
     |;
 
     if ($@) {
         if (defined $opt and $opt & $_INSTALL_DONT_DIE) {
             $JSON::DEBUG and Carp::carp "Can't load $Module_XS...($@)";
             return 0;
         }
         Carp::croak $@;
     }
 
     unless (defined $opt and $opt & $_INSTALL_ONLY) {
         _set_module( $JSON::Backend = $Module_XS );
         my $data = join("", <DATA>); 
         close(DATA);
         eval $data;
         JSON::Backend::XS->init;
     }
 
     return 1;
 };
 
 
 sub _load_pp {
     my $opt = shift;
     my $backend = $_USSING_bpPP ? $Module_bp : $Module_PP;
 
     $JSON::DEBUG and Carp::carp "Load $backend.";
 
     JSON::Boolean::_overrride_overload($Module_XS);
     JSON::Boolean::_overrride_overload($backend);
 
     if ( $_USSING_bpPP ) {
         eval qq| require $backend |;
     }
     else {
         eval qq| use $backend $PP_Version () |;
     }
 
     if ($@) {
         if ( $backend eq $Module_PP ) {
             $JSON::DEBUG and Carp::carp "Can't load $Module_PP ($@), so try to load $Module_bp";
             $_USSING_bpPP++;
             $backend = $Module_bp;
             JSON::Boolean::_overrride_overload($backend);
             local $^W; 
             eval qq| require $Module_bp |;
         }
         Carp::croak $@ if $@;
     }
 
     unless (defined $opt and $opt & $_INSTALL_ONLY) {
         _set_module( $JSON::Backend = $Module_PP ); 
         JSON::Backend::PP->init;
     }
 };
 
 
 sub _set_module {
     return if defined $JSON::true;
 
     my $module = shift;
 
     local $^W;
     no strict qw(refs);
 
     $JSON::true  = ${"$module\::true"};
     $JSON::false = ${"$module\::false"};
 
     push @JSON::ISA, $module;
     if ( JSON->is_xs and JSON->backend->VERSION < 3 ) {
         eval 'package JSON::PP::Boolean';
         push @{"$module\::Boolean::ISA"}, qw(JSON::PP::Boolean);
     }
 
     *{"JSON::is_bool"} = \&{"$module\::is_bool"};
 
     for my $method ($module eq $Module_XS ? @PPOnlyMethods : @XSOnlyMethods) {
         *{"JSON::$method"} = sub {
             Carp::carp("$method is not supported in $module.");
             $_[0];
         };
     }
 
     return 1;
 }
 
 
 
 
 package JSON::Boolean;
 
 my %Installed;
 
 sub _overrride_overload {
     return; 
     return if ($Installed{ $_[0] }++);
 
     my $boolean = $_[0] . '::Boolean';
 
     eval sprintf(q|
         package %s;
         use overload (
             '""' => sub { ${$_[0]} == 1 ? 'true' : 'false' },
             'eq' => sub {
                 my ($obj, $op) = ref ($_[0]) ? ($_[0], $_[1]) : ($_[1], $_[0]);
                 if ($op eq 'true' or $op eq 'false') {
                     return "$obj" eq 'true' ? 'true' eq $op : 'false' eq $op;
                 }
                 else {
                     return $obj ? 1 == $op : 0 == $op;
                 }
             },
         );
     |, $boolean);
 
     if ($@) { Carp::croak $@; }
 
     if ( exists $INC{'JSON/XS.pm'} and $boolean eq 'JSON::XS::Boolean' ) {
         local $^W;
         my $true  = do { bless \(my $dummy = 1), $boolean };
         my $false = do { bless \(my $dummy = 0), $boolean };
         *JSON::XS::true  = sub () { $true };
         *JSON::XS::false = sub () { $false };
     }
     elsif ( exists $INC{'JSON/PP.pm'} and $boolean eq 'JSON::PP::Boolean' ) {
         local $^W;
         my $true  = do { bless \(my $dummy = 1), $boolean };
         my $false = do { bless \(my $dummy = 0), $boolean };
         *JSON::PP::true  = sub { $true };
         *JSON::PP::false = sub { $false };
     }
 
     return 1;
 }
 
 
 
 package JSON::Backend::PP;
 
 sub init {
     local $^W;
     no strict qw(refs); 
     *{"JSON::decode_json"} = \&{"JSON::PP::decode_json"};
     *{"JSON::encode_json"} = \&{"JSON::PP::encode_json"};
     *{"JSON::PP::is_xs"}  = sub { 0 };
     *{"JSON::PP::is_pp"}  = sub { 1 };
     return 1;
 }
 
 
 package JSON;
 
 1;
 __DATA__
 
 
 #
 # Helper classes for Backend Module (XS)
 #
 
 package JSON::Backend::XS;
 
 use constant INDENT_LENGTH_FLAG => 15 << 12;
 
 use constant UNSUPPORTED_ENCODE_FLAG => {
     ESCAPE_SLASH      => 0x00000010,
     ALLOW_BIGNUM      => 0x00000020,
     AS_NONBLESSED     => 0x00000040,
     EXPANDED          => 0x10000000, # for developer's
 };
 
 use constant UNSUPPORTED_DECODE_FLAG => {
     LOOSE             => 0x00000001,
     ALLOW_BIGNUM      => 0x00000002,
     ALLOW_BAREKEY     => 0x00000004,
     ALLOW_SINGLEQUOTE => 0x00000008,
     EXPANDED          => 0x20000000, # for developer's
 };
 
 
 sub init {
     local $^W;
     no strict qw(refs);
     *{"JSON::decode_json"} = \&{"JSON::XS::decode_json"};
     *{"JSON::encode_json"} = \&{"JSON::XS::encode_json"};
     *{"JSON::XS::is_xs"}  = sub { 1 };
     *{"JSON::XS::is_pp"}  = sub { 0 };
     return 1;
 }
 
 
 sub support_by_pp {
     my ($class, @methods) = @_;
 
     local $^W;
     no strict qw(refs);
 
     my $JSON_XS_encode_orignal     = \&JSON::XS::encode;
     my $JSON_XS_decode_orignal     = \&JSON::XS::decode;
     my $JSON_XS_incr_parse_orignal = \&JSON::XS::incr_parse;
 
     *JSON::XS::decode     = \&JSON::Backend::XS::Supportable::_decode;
     *JSON::XS::encode     = \&JSON::Backend::XS::Supportable::_encode;
     *JSON::XS::incr_parse = \&JSON::Backend::XS::Supportable::_incr_parse;
 
     *{JSON::XS::_original_decode}     = $JSON_XS_decode_orignal;
     *{JSON::XS::_original_encode}     = $JSON_XS_encode_orignal;
     *{JSON::XS::_original_incr_parse} = $JSON_XS_incr_parse_orignal;
 
     push @JSON::Backend::XS::Supportable::ISA, 'JSON';
 
     my $pkg = 'JSON::Backend::XS::Supportable';
 
     *{JSON::new} = sub {
         my $proto = JSON::XS->new; $$proto = 0;
         bless  $proto, $pkg;
     };
 
 
     for my $method (@methods) {
         my $flag = uc($method);
         my $type |= (UNSUPPORTED_ENCODE_FLAG->{$flag} || 0);
            $type |= (UNSUPPORTED_DECODE_FLAG->{$flag} || 0);
 
         next unless($type);
 
         $pkg->_make_unsupported_method($method => $type);
     }
 
 #    push @{"JSON::XS::Boolean::ISA"}, qw(JSON::PP::Boolean);
 #    push @{"JSON::PP::Boolean::ISA"}, qw(JSON::Boolean);
 
     $JSON::DEBUG and Carp::carp("set -support_by_pp mode.");
 
     return 1;
 }
 
 
 
 
 #
 # Helper classes for XS
 #
 
 package JSON::Backend::XS::Supportable;
 
 $Carp::Internal{'JSON::Backend::XS::Supportable'} = 1;
 
 sub _make_unsupported_method {
     my ($pkg, $method, $type) = @_;
 
     local $^W;
     no strict qw(refs);
 
     *{"$pkg\::$method"} = sub {
         local $^W;
         if (defined $_[1] ? $_[1] : 1) {
             ${$_[0]} |= $type;
         }
         else {
             ${$_[0]} &= ~$type;
         }
         $_[0];
     };
 
     *{"$pkg\::get_$method"} = sub {
         ${$_[0]} & $type ? 1 : '';
     };
 
 }
 
 
 sub _set_for_pp {
     JSON::_load_pp( $_INSTALL_ONLY );
 
     my $type  = shift;
     my $pp    = JSON::PP->new;
     my $prop = $_[0]->property;
 
     for my $name (keys %$prop) {
         $pp->$name( $prop->{$name} ? $prop->{$name} : 0 );
     }
 
     my $unsupported = $type eq 'encode' ? JSON::Backend::XS::UNSUPPORTED_ENCODE_FLAG
                                         : JSON::Backend::XS::UNSUPPORTED_DECODE_FLAG;
     my $flags       = ${$_[0]} || 0;
 
     for my $name (keys %$unsupported) {
         next if ($name eq 'EXPANDED'); # for developer's
         my $enable = ($flags & $unsupported->{$name}) ? 1 : 0;
         my $method = lc $name;
         $pp->$method($enable);
     }
 
     $pp->indent_length( $_[0]->get_indent_length );
 
     return $pp;
 }
 
 sub _encode { # using with PP encode
     if (${$_[0]}) {
         _set_for_pp('encode' => @_)->encode($_[1]);
     }
     else {
         $_[0]->_original_encode( $_[1] );
     }
 }
 
 
 sub _decode { # if unsupported-flag is set, use PP
     if (${$_[0]}) {
         _set_for_pp('decode' => @_)->decode($_[1]);
     }
     else {
         $_[0]->_original_decode( $_[1] );
     }
 }
 
 
 sub decode_prefix { # if unsupported-flag is set, use PP
     _set_for_pp('decode' => @_)->decode_prefix($_[1]);
 }
 
 
 sub _incr_parse {
     if (${$_[0]}) {
         _set_for_pp('decode' => @_)->incr_parse($_[1]);
     }
     else {
         $_[0]->_original_incr_parse( $_[1] );
     }
 }
 
 
 sub get_indent_length {
     ${$_[0]} << 4 >> 16;
 }
 
 
 sub indent_length {
     my $length = $_[1];
 
     if (!defined $length or $length > 15 or $length < 0) {
         Carp::carp "The acceptable range of indent_length() is 0 to 15.";
     }
     else {
         local $^W;
         $length <<= 12;
         ${$_[0]} &= ~ JSON::Backend::XS::INDENT_LENGTH_FLAG;
         ${$_[0]} |= $length;
         *JSON::XS::encode = \&JSON::Backend::XS::Supportable::_encode;
     }
 
     $_[0];
 }
 
 
 1;
 __END__
 
 =head1 NAME
 
 JSON - JSON (JavaScript Object Notation) encoder/decoder
 
 =head1 SYNOPSIS
 
  use JSON; # imports encode_json, decode_json, to_json and from_json.
  
  # simple and fast interfaces (expect/generate UTF-8)
  
  $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref;
  $perl_hash_or_arrayref  = decode_json $utf8_encoded_json_text;
  
  # OO-interface
  
  $json = JSON->new->allow_nonref;
  
  $json_text   = $json->encode( $perl_scalar );
  $perl_scalar = $json->decode( $json_text );
  
  $pretty_printed = $json->pretty->encode( $perl_scalar ); # pretty-printing
  
  # If you want to use PP only support features, call with '-support_by_pp'
  # When XS unsupported feature is enable, using PP (de|en)code instead of XS ones.
  
  use JSON -support_by_pp;
  
  # option-acceptable interfaces (expect/generate UNICODE by default)
  
  $json_text   = to_json( $perl_scalar, { ascii => 1, pretty => 1 } );
  $perl_scalar = from_json( $json_text, { utf8  => 1 } );
  
  # Between (en|de)code_json and (to|from)_json, if you want to write
  # a code which communicates to an outer world (encoded in UTF-8),
  # recommend to use (en|de)code_json.
  
 =head1 VERSION
 
     2.90
 
 This version is compatible with JSON::XS B<2.34> and later.
 (Not yet compatble to JSON::XS B<3.0x>.)
 
 
 =head1 NOTE
 
 JSON::PP was earlier included in the C<JSON> distribution, but
 has since Perl 5.14 been a core module. For this reason,
 L<JSON::PP> was removed from the JSON distribution and can now
 be found also in the Perl5 repository at
 
 =over
 
 =item * L<http://perl5.git.perl.org/perl.git>
 
 =back
 
 (The newest JSON::PP version still exists in CPAN.)
 
 Instead, the C<JSON> distribution will include JSON::backportPP
 for backwards computability. JSON.pm should thus work as it did
 before.
 
 =head1 DESCRIPTION
 
  *************************** CAUTION **************************************
  *                                                                        *
  * INCOMPATIBLE CHANGE (JSON::XS version 2.90)                            *
  *                                                                        *
  * JSON.pm had patched JSON::XS::Boolean and JSON::PP::Boolean internally *
  * on loading time for making these modules inherit JSON::Boolean.        *
  * But since JSON::XS v3.0 it use Types::Serialiser as boolean class.     *
  * Then now JSON.pm breaks boolean classe overload features and           *
  * -support_by_pp if JSON::XS v3.0 or later is installed.                 *
  *                                                                        *
  * JSON::true and JSON::false returned JSON::Boolean objects.             *
  * For workaround, they return JSON::PP::Boolean objects in this version. *
  *                                                                        *
  *     isa_ok(JSON::true, 'JSON::PP::Boolean');                           *
  *                                                                        *
  * And it discards a feature:                                             *
  *                                                                        *
  *     ok(JSON::true eq 'true');                                          *
  *                                                                        *
  * In other word, JSON::PP::Boolean overload numeric only.                *
  *                                                                        *
  *     ok( JSON::true == 1 );                                             *
  *                                                                        *
  **************************************************************************
 
  ************************** CAUTION ********************************
  * This is 'JSON module version 2' and there are many differences  *
  * to version 1.xx                                                 *
  * Please check your applications using old version.              *
  *   See to 'INCOMPATIBLE CHANGES TO OLD VERSION'                  *
  *******************************************************************
 
 JSON (JavaScript Object Notation) is a simple data format.
 See to L<http://www.json.org/> and C<RFC4627>(L<http://www.ietf.org/rfc/rfc4627.txt>).
 
 This module converts Perl data structures to JSON and vice versa using either
 L<JSON::XS> or L<JSON::PP>.
 
 JSON::XS is the fastest and most proper JSON module on CPAN which must be
 compiled and installed in your environment.
 JSON::PP is a pure-Perl module which is bundled in this distribution and
 has a strong compatibility to JSON::XS.
 
 This module try to use JSON::XS by default and fail to it, use JSON::PP instead.
 So its features completely depend on JSON::XS or JSON::PP.
 
 See to L<BACKEND MODULE DECISION>.
 
 To distinguish the module name 'JSON' and the format type JSON,
 the former is quoted by CE<lt>E<gt> (its results vary with your using media),
 and the latter is left just as it is.
 
 Module name : C<JSON>
 
 Format type : JSON
 
 =head2 FEATURES
 
 =over
 
 =item * correct unicode handling
 
 This module (i.e. backend modules) knows how to handle Unicode, documents
 how and when it does so, and even documents what "correct" means.
 
 Even though there are limitations, this feature is available since Perl version 5.6.
 
 JSON::XS requires Perl 5.8.2 (but works correctly in 5.8.8 or later), so in older versions
 C<JSON> should call JSON::PP as the backend which can be used since Perl 5.005.
 
 With Perl 5.8.x JSON::PP works, but from 5.8.0 to 5.8.2, because of a Perl side problem,
 JSON::PP works slower in the versions. And in 5.005, the Unicode handling is not available.
 See to L<JSON::PP/UNICODE HANDLING ON PERLS> for more information.
 
 See also to L<JSON::XS/A FEW NOTES ON UNICODE AND PERL>
 and L<JSON::XS/ENCODING/CODESET_FLAG_NOTES>.
 
 
 =item * round-trip integrity
 
 When you serialise a perl data structure using only data types supported
 by JSON and Perl, the deserialised data structure is identical on the Perl
 level. (e.g. the string "2.0" doesn't suddenly become "2" just because
 it looks like a number). There I<are> minor exceptions to this, read the
 L</MAPPING> section below to learn about those.
 
 
 =item * strict checking of JSON correctness
 
 There is no guessing, no generating of illegal JSON texts by default,
 and only JSON is accepted as input by default (the latter is a security
 feature).
 
 See to L<JSON::XS/FEATURES> and L<JSON::PP/FEATURES>.
 
 =item * fast
 
 This module returns a JSON::XS object itself if available.
 Compared to other JSON modules and other serialisers such as Storable,
 JSON::XS usually compares favorably in terms of speed, too.
 
 If not available, C<JSON> returns a JSON::PP object instead of JSON::XS and
 it is very slow as pure-Perl.
 
 =item * simple to use
 
 This module has both a simple functional interface as well as an
 object oriented interface interface.
 
 =item * reasonably versatile output formats
 
 You can choose between the most compact guaranteed-single-line format possible
 (nice for simple line-based protocols), a pure-ASCII format (for when your transport
 is not 8-bit clean, still supports the whole Unicode range), or a pretty-printed
 format (for when you want to read that stuff). Or you can combine those features
 in whatever way you like.
 
 =back
 
 =head1 FUNCTIONAL INTERFACE
 
 Some documents are copied and modified from L<JSON::XS/FUNCTIONAL INTERFACE>.
 C<to_json> and C<from_json> are additional functions.
 
 =head2 encode_json
 
     $json_text = encode_json $perl_scalar
 
 Converts the given Perl data structure to a UTF-8 encoded, binary string.
 
 This function call is functionally identical to:
 
     $json_text = JSON->new->utf8->encode($perl_scalar)
 
 =head2 decode_json
 
     $perl_scalar = decode_json $json_text
 
 The opposite of C<encode_json>: expects an UTF-8 (binary) string and tries
 to parse that as an UTF-8 encoded JSON text, returning the resulting
 reference.
 
 This function call is functionally identical to:
 
     $perl_scalar = JSON->new->utf8->decode($json_text)
 
 
 =head2 to_json
 
    $json_text = to_json($perl_scalar)
 
 Converts the given Perl data structure to a json string.
 
 This function call is functionally identical to:
 
    $json_text = JSON->new->encode($perl_scalar)
 
 Takes a hash reference as the second.
 
    $json_text = to_json($perl_scalar, $flag_hashref)
 
 So,
 
    $json_text = to_json($perl_scalar, {utf8 => 1, pretty => 1})
 
 equivalent to:
 
    $json_text = JSON->new->utf8(1)->pretty(1)->encode($perl_scalar)
 
 If you want to write a modern perl code which communicates to outer world,
 you should use C<encode_json> (supposed that JSON data are encoded in UTF-8).
 
 =head2 from_json
 
    $perl_scalar = from_json($json_text)
 
 The opposite of C<to_json>: expects a json string and tries
 to parse it, returning the resulting reference.
 
 This function call is functionally identical to:
 
     $perl_scalar = JSON->decode($json_text)
 
 Takes a hash reference as the second.
 
     $perl_scalar = from_json($json_text, $flag_hashref)
 
 So,
 
     $perl_scalar = from_json($json_text, {utf8 => 1})
 
 equivalent to:
 
     $perl_scalar = JSON->new->utf8(1)->decode($json_text)
 
 If you want to write a modern perl code which communicates to outer world,
 you should use C<decode_json> (supposed that JSON data are encoded in UTF-8).
 
 =head2 JSON::is_bool
 
     $is_boolean = JSON::is_bool($scalar)
 
 Returns true if the passed scalar represents either JSON::true or
 JSON::false, two constants that act like C<1> and C<0> respectively
 and are also used to represent JSON C<true> and C<false> in Perl strings.
 
 =head2 JSON::true
 
 Returns JSON true value which is blessed object.
 It C<isa> JSON::Boolean object.
 
 =head2 JSON::false
 
 Returns JSON false value which is blessed object.
 It C<isa> JSON::Boolean object.
 
 =head2 JSON::null
 
 Returns C<undef>.
 
 See L<MAPPING>, below, for more information on how JSON values are mapped to
 Perl.
 
 =head1 HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER
 
 This section supposes that your perl version is 5.8 or later.
 
 If you know a JSON text from an outer world - a network, a file content, and so on,
 is encoded in UTF-8, you should use C<decode_json> or C<JSON> module object
 with C<utf8> enable. And the decoded result will contain UNICODE characters.
 
   # from network
   my $json        = JSON->new->utf8;
   my $json_text   = CGI->new->param( 'json_data' );
   my $perl_scalar = $json->decode( $json_text );
   
   # from file content
   local $/;
   open( my $fh, '<', 'json.data' );
   $json_text   = <$fh>;
   $perl_scalar = decode_json( $json_text );
 
 If an outer data is not encoded in UTF-8, firstly you should C<decode> it.
 
   use Encode;
   local $/;
   open( my $fh, '<', 'json.data' );
   my $encoding = 'cp932';
   my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE
   
   # or you can write the below code.
   #
   # open( my $fh, "<:encoding($encoding)", 'json.data' );
   # $unicode_json_text = <$fh>;
 
 In this case, C<$unicode_json_text> is of course UNICODE string.
 So you B<cannot> use C<decode_json> nor C<JSON> module object with C<utf8> enable.
 Instead of them, you use C<JSON> module object with C<utf8> disable or C<from_json>.
 
   $perl_scalar = $json->utf8(0)->decode( $unicode_json_text );
   # or
   $perl_scalar = from_json( $unicode_json_text );
 
 Or C<encode 'utf8'> and C<decode_json>:
 
   $perl_scalar = decode_json( encode( 'utf8', $unicode_json_text ) );
   # this way is not efficient.
 
 And now, you want to convert your C<$perl_scalar> into JSON data and
 send it to an outer world - a network or a file content, and so on.
 
 Your data usually contains UNICODE strings and you want the converted data to be encoded
 in UTF-8, you should use C<encode_json> or C<JSON> module object with C<utf8> enable.
 
   print encode_json( $perl_scalar ); # to a network? file? or display?
   # or
   print $json->utf8->encode( $perl_scalar );
 
 If C<$perl_scalar> does not contain UNICODE but C<$encoding>-encoded strings
 for some reason, then its characters are regarded as B<latin1> for perl
 (because it does not concern with your $encoding).
 You B<cannot> use C<encode_json> nor C<JSON> module object with C<utf8> enable.
 Instead of them, you use C<JSON> module object with C<utf8> disable or C<to_json>.
 Note that the resulted text is a UNICODE string but no problem to print it.
 
   # $perl_scalar contains $encoding encoded string values
   $unicode_json_text = $json->utf8(0)->encode( $perl_scalar );
   # or 
   $unicode_json_text = to_json( $perl_scalar );
   # $unicode_json_text consists of characters less than 0x100
   print $unicode_json_text;
 
 Or C<decode $encoding> all string values and C<encode_json>:
 
   $perl_scalar->{ foo } = decode( $encoding, $perl_scalar->{ foo } );
   # ... do it to each string values, then encode_json
   $json_text = encode_json( $perl_scalar );
 
 This method is a proper way but probably not efficient.
 
 See to L<Encode>, L<perluniintro>.
 
 
 =head1 COMMON OBJECT-ORIENTED INTERFACE
 
 =head2 new
 
     $json = JSON->new
 
 Returns a new C<JSON> object inherited from either JSON::XS or JSON::PP
 that can be used to de/encode JSON strings.
 
 All boolean flags described below are by default I<disabled>.
 
 The mutators for flags all return the JSON object again and thus calls can
 be chained:
 
    my $json = JSON->new->utf8->space_after->encode({a => [1,2]})
    => {"a": [1, 2]}
 
 =head2 ascii
 
     $json = $json->ascii([$enable])
     
     $enabled = $json->get_ascii
 
 If $enable is true (or missing), then the encode method will not generate characters outside
 the code range 0..127. Any Unicode characters outside that range will be escaped using either
 a single \uXXXX or a double \uHHHH\uLLLLL escape sequence, as per RFC4627.
 
 If $enable is false, then the encode method will not escape Unicode characters unless
 required by the JSON syntax or other flags. This results in a faster and more compact format.
 
 This feature depends on the used Perl version and environment.
 
 See to L<JSON::PP/UNICODE HANDLING ON PERLS> if the backend is PP.
 
   JSON->new->ascii(1)->encode([chr 0x10401])
   => ["\ud801\udc01"]
 
 =head2 latin1
 
     $json = $json->latin1([$enable])
     
     $enabled = $json->get_latin1
 
 If $enable is true (or missing), then the encode method will encode the resulting JSON
 text as latin1 (or iso-8859-1), escaping any characters outside the code range 0..255.
 
 If $enable is false, then the encode method will not escape Unicode characters
 unless required by the JSON syntax or other flags.
 
   JSON->new->latin1->encode (["\x{89}\x{abc}"]
   => ["\x{89}\\u0abc"]    # (perl syntax, U+abc escaped, U+89 not)
 
 =head2 utf8
 
     $json = $json->utf8([$enable])
     
     $enabled = $json->get_utf8
 
 If $enable is true (or missing), then the encode method will encode the JSON result
 into UTF-8, as required by many protocols, while the decode method expects to be handled
 an UTF-8-encoded string. Please note that UTF-8-encoded strings do not contain any
 characters outside the range 0..255, they are thus useful for bytewise/binary I/O.
 
 In future versions, enabling this option might enable autodetection of the UTF-16 and UTF-32
 encoding families, as described in RFC4627.
 
 If $enable is false, then the encode method will return the JSON string as a (non-encoded)
 Unicode string, while decode expects thus a Unicode string. Any decoding or encoding
 (e.g. to UTF-8 or UTF-16) needs to be done yourself, e.g. using the Encode module.
 
 
 Example, output UTF-16BE-encoded JSON:
 
   use Encode;
   $jsontext = encode "UTF-16BE", JSON::XS->new->encode ($object);
 
 Example, decode UTF-32LE-encoded JSON:
 
   use Encode;
   $object = JSON::XS->new->decode (decode "UTF-32LE", $jsontext);
 
 See to L<JSON::PP/UNICODE HANDLING ON PERLS> if the backend is PP.
 
 
 =head2 pretty
 
     $json = $json->pretty([$enable])
 
 This enables (or disables) all of the C<indent>, C<space_before> and
 C<space_after> (and in the future possibly more) flags in one call to
 generate the most readable (or most compact) form possible.
 
 Equivalent to:
 
    $json->indent->space_before->space_after
 
 The indent space length is three and JSON::XS cannot change the indent
 space length.
 
 =head2 indent
 
     $json = $json->indent([$enable])
     
     $enabled = $json->get_indent
 
 If C<$enable> is true (or missing), then the C<encode> method will use a multiline
 format as output, putting every array member or object/hash key-value pair
 into its own line, identifying them properly.
 
 If C<$enable> is false, no newlines or indenting will be produced, and the
 resulting JSON text is guaranteed not to contain any C<newlines>.
 
 This setting has no effect when decoding JSON texts.
 
 The indent space length is three.
 With JSON::PP, you can also access C<indent_length> to change indent space length.
 
 
 =head2 space_before
 
     $json = $json->space_before([$enable])
     
     $enabled = $json->get_space_before
 
 If C<$enable> is true (or missing), then the C<encode> method will add an extra
 optional space before the C<:> separating keys from values in JSON objects.
 
 If C<$enable> is false, then the C<encode> method will not add any extra
 space at those places.
 
 This setting has no effect when decoding JSON texts.
 
 Example, space_before enabled, space_after and indent disabled:
 
    {"key" :"value"}
 
 
 =head2 space_after
 
     $json = $json->space_after([$enable])
     
     $enabled = $json->get_space_after
 
 If C<$enable> is true (or missing), then the C<encode> method will add an extra
 optional space after the C<:> separating keys from values in JSON objects
 and extra whitespace after the C<,> separating key-value pairs and array
 members.
 
 If C<$enable> is false, then the C<encode> method will not add any extra
 space at those places.
 
 This setting has no effect when decoding JSON texts.
 
 Example, space_before and indent disabled, space_after enabled:
 
    {"key": "value"}
 
 
 =head2 relaxed
 
     $json = $json->relaxed([$enable])
     
     $enabled = $json->get_relaxed
 
 If C<$enable> is true (or missing), then C<decode> will accept some
 extensions to normal JSON syntax (see below). C<encode> will not be
 affected in anyway. I<Be aware that this option makes you accept invalid
 JSON texts as if they were valid!>. I suggest only to use this option to
 parse application-specific files written by humans (configuration files,
 resource files etc.)
 
 If C<$enable> is false (the default), then C<decode> will only accept
 valid JSON texts.
 
 Currently accepted extensions are:
 
 =over 4
 
 =item * list items can have an end-comma
 
 JSON I<separates> array elements and key-value pairs with commas. This
 can be annoying if you write JSON texts manually and want to be able to
 quickly append elements, so this extension accepts comma at the end of
 such items not just between them:
 
    [
       1,
       2, <- this comma not normally allowed
    ]
    {
       "k1": "v1",
       "k2": "v2", <- this comma not normally allowed
    }
 
 =item * shell-style '#'-comments
 
 Whenever JSON allows whitespace, shell-style comments are additionally
 allowed. They are terminated by the first carriage-return or line-feed
 character, after which more white-space and comments are allowed.
 
   [
      1, # this comment not allowed in JSON
         # neither this one...
   ]
 
 =back
 
 
 =head2 canonical
 
     $json = $json->canonical([$enable])
     
     $enabled = $json->get_canonical
 
 If C<$enable> is true (or missing), then the C<encode> method will output JSON objects
 by sorting their keys. This is adding a comparatively high overhead.
 
 If C<$enable> is false, then the C<encode> method will output key-value
 pairs in the order Perl stores them (which will likely change between runs
 of the same script).
 
 This option is useful if you want the same data structure to be encoded as
 the same JSON text (given the same overall settings). If it is disabled,
 the same hash might be encoded differently even if contains the same data,
 as key-value pairs have no inherent ordering in Perl.
 
 This setting has no effect when decoding JSON texts.
 
 =head2 allow_nonref
 
     $json = $json->allow_nonref([$enable])
     
     $enabled = $json->get_allow_nonref
 
 If C<$enable> is true (or missing), then the C<encode> method can convert a
 non-reference into its corresponding string, number or null JSON value,
 which is an extension to RFC4627. Likewise, C<decode> will accept those JSON
 values instead of croaking.
 
 If C<$enable> is false, then the C<encode> method will croak if it isn't
 passed an arrayref or hashref, as JSON texts must either be an object
 or array. Likewise, C<decode> will croak if given something that is not a
 JSON object or array.
 
    JSON->new->allow_nonref->encode ("Hello, World!")
    => "Hello, World!"
 
 =head2 allow_unknown
 
     $json = $json->allow_unknown ([$enable])
     
     $enabled = $json->get_allow_unknown
 
 If $enable is true (or missing), then "encode" will *not* throw an
 exception when it encounters values it cannot represent in JSON (for
 example, filehandles) but instead will encode a JSON "null" value.
 Note that blessed objects are not included here and are handled
 separately by c<allow_nonref>.
 
 If $enable is false (the default), then "encode" will throw an
 exception when it encounters anything it cannot encode as JSON.
 
 This option does not affect "decode" in any way, and it is
 recommended to leave it off unless you know your communications
 partner.
 
 =head2 allow_blessed
 
     $json = $json->allow_blessed([$enable])
     
     $enabled = $json->get_allow_blessed
 
 If C<$enable> is true (or missing), then the C<encode> method will not
 barf when it encounters a blessed reference. Instead, the value of the
 B<convert_blessed> option will decide whether C<null> (C<convert_blessed>
 disabled or no C<TO_JSON> method found) or a representation of the
 object (C<convert_blessed> enabled and C<TO_JSON> method found) is being
 encoded. Has no effect on C<decode>.
 
 If C<$enable> is false (the default), then C<encode> will throw an
 exception when it encounters a blessed object.
 
 
 =head2 convert_blessed
 
     $json = $json->convert_blessed([$enable])
     
     $enabled = $json->get_convert_blessed
 
 If C<$enable> is true (or missing), then C<encode>, upon encountering a
 blessed object, will check for the availability of the C<TO_JSON> method
 on the object's class. If found, it will be called in scalar context
 and the resulting scalar will be encoded instead of the object. If no
 C<TO_JSON> method is found, the value of C<allow_blessed> will decide what
 to do.
 
 The C<TO_JSON> method may safely call die if it wants. If C<TO_JSON>
 returns other blessed objects, those will be handled in the same
 way. C<TO_JSON> must take care of not causing an endless recursion cycle
 (== crash) in this case. The name of C<TO_JSON> was chosen because other
 methods called by the Perl core (== not by the user of the object) are
 usually in upper case letters and to avoid collisions with the C<to_json>
 function or method.
 
 This setting does not yet influence C<decode> in any way.
 
 If C<$enable> is false, then the C<allow_blessed> setting will decide what
 to do when a blessed object is found.
 
 =over
 
 =item convert_blessed_universally mode
 
 If use C<JSON> with C<-convert_blessed_universally>, the C<UNIVERSAL::TO_JSON>
 subroutine is defined as the below code:
 
    *UNIVERSAL::TO_JSON = sub {
        my $b_obj = B::svref_2object( $_[0] );
        return    $b_obj->isa('B::HV') ? { %{ $_[0] } }
                : $b_obj->isa('B::AV') ? [ @{ $_[0] } ]
                : undef
                ;
    }
 
 This will cause that C<encode> method converts simple blessed objects into
 JSON objects as non-blessed object.
 
    JSON -convert_blessed_universally;
    $json->allow_blessed->convert_blessed->encode( $blessed_object )
 
 This feature is experimental and may be removed in the future.
 
 =back
 
 =head2 filter_json_object
 
     $json = $json->filter_json_object([$coderef])
 
 When C<$coderef> is specified, it will be called from C<decode> each
 time it decodes a JSON object. The only argument passed to the coderef
 is a reference to the newly-created hash. If the code references returns
 a single scalar (which need not be a reference), this value
 (i.e. a copy of that scalar to avoid aliasing) is inserted into the
 deserialised data structure. If it returns an empty list
 (NOTE: I<not> C<undef>, which is a valid scalar), the original deserialised
 hash will be inserted. This setting can slow down decoding considerably.
 
 When C<$coderef> is omitted or undefined, any existing callback will
 be removed and C<decode> will not change the deserialised hash in any
 way.
 
 Example, convert all JSON objects into the integer 5:
 
    my $js = JSON->new->filter_json_object (sub { 5 });
    # returns [5]
    $js->decode ('[{}]'); # the given subroutine takes a hash reference.
    # throw an exception because allow_nonref is not enabled
    # so a lone 5 is not allowed.
    $js->decode ('{"a":1, "b":2}');
 
 
 =head2 filter_json_single_key_object
 
     $json = $json->filter_json_single_key_object($key [=> $coderef])
 
 Works remotely similar to C<filter_json_object>, but is only called for
 JSON objects having a single key named C<$key>.
 
 This C<$coderef> is called before the one specified via
 C<filter_json_object>, if any. It gets passed the single value in the JSON
 object. If it returns a single value, it will be inserted into the data
 structure. If it returns nothing (not even C<undef> but the empty list),
 the callback from C<filter_json_object> will be called next, as if no
 single-key callback were specified.
 
 If C<$coderef> is omitted or undefined, the corresponding callback will be
 disabled. There can only ever be one callback for a given key.
 
 As this callback gets called less often then the C<filter_json_object>
 one, decoding speed will not usually suffer as much. Therefore, single-key
 objects make excellent targets to serialise Perl objects into, especially
 as single-key JSON objects are as close to the type-tagged value concept
 as JSON gets (it's basically an ID/VALUE tuple). Of course, JSON does not
 support this in any way, so you need to make sure your data never looks
 like a serialised Perl hash.
 
 Typical names for the single object key are C<__class_whatever__>, or
 C<$__dollars_are_rarely_used__$> or C<}ugly_brace_placement>, or even
 things like C<__class_md5sum(classname)__>, to reduce the risk of clashing
 with real hashes.
 
 Example, decode JSON objects of the form C<< { "__widget__" => <id> } >>
 into the corresponding C<< $WIDGET{<id>} >> object:
 
    # return whatever is in $WIDGET{5}:
    JSON
       ->new
       ->filter_json_single_key_object (__widget__ => sub {
             $WIDGET{ $_[0] }
          })
       ->decode ('{"__widget__": 5')
 
    # this can be used with a TO_JSON method in some "widget" class
    # for serialisation to json:
    sub WidgetBase::TO_JSON {
       my ($self) = @_;
 
       unless ($self->{id}) {
          $self->{id} = ..get..some..id..;
          $WIDGET{$self->{id}} = $self;
       }
 
       { __widget__ => $self->{id} }
    }
 
 
 =head2 shrink
 
     $json = $json->shrink([$enable])
     
     $enabled = $json->get_shrink
 
 With JSON::XS, this flag resizes strings generated by either
 C<encode> or C<decode> to their minimum size possible. This can save
 memory when your JSON texts are either very very long or you have many
 short strings. It will also try to downgrade any strings to octet-form
 if possible: perl stores strings internally either in an encoding called
 UTF-X or in octet-form. The latter cannot store everything but uses less
 space in general (and some buggy Perl or C code might even rely on that
 internal representation being used).
 
 With JSON::PP, it is noop about resizing strings but tries
 C<utf8::downgrade> to the returned string by C<encode>. See to L<utf8>.
 
 See to L<JSON::XS/OBJECT-ORIENTED INTERFACE> and L<JSON::PP/METHODS>.
 
 =head2 max_depth
 
     $json = $json->max_depth([$maximum_nesting_depth])
     
     $max_depth = $json->get_max_depth
 
 Sets the maximum nesting level (default C<512>) accepted while encoding
 or decoding. If a higher nesting level is detected in JSON text or a Perl
 data structure, then the encoder and decoder will stop and croak at that
 point.
 
 Nesting level is defined by number of hash- or arrayrefs that the encoder
 needs to traverse to reach a given point or the number of C<{> or C<[>
 characters without their matching closing parenthesis crossed to reach a
 given character in a string.
 
 If no argument is given, the highest possible setting will be used, which
 is rarely useful.
 
 Note that nesting is implemented by recursion in C. The default value has
 been chosen to be as large as typical operating systems allow without
 crashing. (JSON::XS)
 
 With JSON::PP as the backend, when a large value (100 or more) was set and
 it de/encodes a deep nested object/text, it may raise a warning
 'Deep recursion on subroutine' at the perl runtime phase.
 
 See L<JSON::XS/SECURITY CONSIDERATIONS> for more info on why this is useful.
 
 =head2 max_size
 
     $json = $json->max_size([$maximum_string_size])
     
     $max_size = $json->get_max_size
 
 Set the maximum length a JSON text may have (in bytes) where decoding is
 being attempted. The default is C<0>, meaning no limit. When C<decode>
 is called on a string that is longer then this many bytes, it will not
 attempt to decode the string but throw an exception. This setting has no
 effect on C<encode> (yet).
 
 If no argument is given, the limit check will be deactivated (same as when
 C<0> is specified).
 
 See L<JSON::XS/SECURITY CONSIDERATIONS>, below, for more info on why this is useful.
 
 =head2 encode
 
     $json_text = $json->encode($perl_scalar)
 
 Converts the given Perl data structure (a simple scalar or a reference
 to a hash or array) to its JSON representation. Simple scalars will be
 converted into JSON string or number sequences, while references to arrays
 become JSON arrays and references to hashes become JSON objects. Undefined
 Perl values (e.g. C<undef>) become JSON C<null> values.
 References to the integers C<0> and C<1> are converted into C<true> and C<false>.
 
 =head2 decode
 
     $perl_scalar = $json->decode($json_text)
 
 The opposite of C<encode>: expects a JSON text and tries to parse it,
 returning the resulting simple scalar or reference. Croaks on error.
 
 JSON numbers and strings become simple Perl scalars. JSON arrays become
 Perl arrayrefs and JSON objects become Perl hashrefs. C<true> becomes
 C<1> (C<JSON::true>), C<false> becomes C<0> (C<JSON::false>) and
 C<null> becomes C<undef>.
 
 =head2 decode_prefix
 
     ($perl_scalar, $characters) = $json->decode_prefix($json_text)
 
 This works like the C<decode> method, but instead of raising an exception
 when there is trailing garbage after the first JSON object, it will
 silently stop parsing there and return the number of characters consumed
 so far.
 
    JSON->new->decode_prefix ("[1] the tail")
    => ([], 3)
 
 See to L<JSON::XS/OBJECT-ORIENTED INTERFACE>
 
 =head2 property
 
     $boolean = $json->property($property_name)
 
 Returns a boolean value about above some properties.
 
 The available properties are C<ascii>, C<latin1>, C<utf8>,
 C<indent>,C<space_before>, C<space_after>, C<relaxed>, C<canonical>,
 C<allow_nonref>, C<allow_unknown>, C<allow_blessed>, C<convert_blessed>,
 C<shrink>, C<max_depth> and C<max_size>.
 
    $boolean = $json->property('utf8');
     => 0
    $json->utf8;
    $boolean = $json->property('utf8');
     => 1
 
 Sets the property with a given boolean value.
 
     $json = $json->property($property_name => $boolean);
 
 With no argument, it returns all the above properties as a hash reference.
 
     $flag_hashref = $json->property();
 
 =head1 INCREMENTAL PARSING
 
 Most of this section are copied and modified from L<JSON::XS/INCREMENTAL PARSING>.
 
 In some cases, there is the need for incremental parsing of JSON texts.
 This module does allow you to parse a JSON stream incrementally.
 It does so by accumulating text until it has a full JSON object, which
 it then can decode. This process is similar to using C<decode_prefix>
 to see if a full JSON object is available, but is much more efficient
 (and can be implemented with a minimum of method calls).
 
 The backend module will only attempt to parse the JSON text once it is sure it
 has enough text to get a decisive result, using a very simple but
 truly incremental parser. This means that it sometimes won't stop as
 early as the full parser, for example, it doesn't detect parenthesis
 mismatches. The only thing it guarantees is that it starts decoding as
 soon as a syntactically valid JSON text has been seen. This means you need
 to set resource limits (e.g. C<max_size>) to ensure the parser will stop
 parsing in the presence if syntax errors.
 
 The following methods implement this incremental parser.
 
 =head2 incr_parse
 
     $json->incr_parse( [$string] ) # void context
     
     $obj_or_undef = $json->incr_parse( [$string] ) # scalar context
     
     @obj_or_empty = $json->incr_parse( [$string] ) # list context
 
 This is the central parsing function. It can both append new text and
 extract objects from the stream accumulated so far (both of these
 functions are optional).
 
 If C<$string> is given, then this string is appended to the already
 existing JSON fragment stored in the C<$json> object.
 
 After that, if the function is called in void context, it will simply
 return without doing anything further. This can be used to add more text
 in as many chunks as you want.
 
 If the method is called in scalar context, then it will try to extract
 exactly I<one> JSON object. If that is successful, it will return this
 object, otherwise it will return C<undef>. If there is a parse error,
 this method will croak just as C<decode> would do (one can then use
 C<incr_skip> to skip the erroneous part). This is the most common way of
 using the method.
 
 And finally, in list context, it will try to extract as many objects
 from the stream as it can find and return them, or the empty list
 otherwise. For this to work, there must be no separators between the JSON
 objects or arrays, instead they must be concatenated back-to-back. If
 an error occurs, an exception will be raised as in the scalar context
 case. Note that in this case, any previously-parsed JSON texts will be
 lost.
 
 Example: Parse some JSON arrays/objects in a given string and return them.
 
     my @objs = JSON->new->incr_parse ("[5][7][1,2]");
 
 =head2 incr_text
 
     $lvalue_string = $json->incr_text
 
 This method returns the currently stored JSON fragment as an lvalue, that
 is, you can manipulate it. This I<only> works when a preceding call to
 C<incr_parse> in I<scalar context> successfully returned an object. Under
 all other circumstances you must not call this function (I mean it.
 although in simple tests it might actually work, it I<will> fail under
 real world conditions). As a special exception, you can also call this
 method before having parsed anything.
 
 This function is useful in two cases: a) finding the trailing text after a
 JSON object or b) parsing multiple JSON objects separated by non-JSON text
 (such as commas).
 
     $json->incr_text =~ s/\s*,\s*//;
 
 In Perl 5.005, C<lvalue> attribute is not available.
 You must write codes like the below:
 
     $string = $json->incr_text;
     $string =~ s/\s*,\s*//;
     $json->incr_text( $string );
 
 =head2 incr_skip
 
     $json->incr_skip
 
 This will reset the state of the incremental parser and will remove the
 parsed text from the input buffer. This is useful after C<incr_parse>
 died, in which case the input buffer and incremental parser state is left
 unchanged, to skip the text parsed so far and to reset the parse state.
 
 =head2 incr_reset
 
     $json->incr_reset
 
 This completely resets the incremental parser, that is, after this call,
 it will be as if the parser had never parsed anything.
 
 This is useful if you want to repeatedly parse JSON objects and want to
 ignore any trailing data, which means you have to reset the parser after
 each successful decode.
 
 See to L<JSON::XS/INCREMENTAL PARSING> for examples.
 
 
 =head1 JSON::PP SUPPORT METHODS
 
 The below methods are JSON::PP own methods, so when C<JSON> works
 with JSON::PP (i.e. the created object is a JSON::PP object), available.
 See to L<JSON::PP/JSON::PP OWN METHODS> in detail.
 
 If you use C<JSON> with additional C<-support_by_pp>, some methods
 are available even with JSON::XS. See to L<USE PP FEATURES EVEN THOUGH XS BACKEND>.
 
    BEING { $ENV{PERL_JSON_BACKEND} = 'JSON::XS' }
    
    use JSON -support_by_pp;
    
    my $json = JSON->new;
    $json->allow_nonref->escape_slash->encode("/");
 
    # functional interfaces too.
    print to_json(["/"], {escape_slash => 1});
    print from_json('["foo"]', {utf8 => 1});
 
 If you do not want to all functions but C<-support_by_pp>,
 use C<-no_export>.
 
    use JSON -support_by_pp, -no_export;
    # functional interfaces are not exported.
 
 =head2 allow_singlequote
 
     $json = $json->allow_singlequote([$enable])
 
 If C<$enable> is true (or missing), then C<decode> will accept
 any JSON strings quoted by single quotations that are invalid JSON
 format.
 
     $json->allow_singlequote->decode({"foo":'bar'});
     $json->allow_singlequote->decode({'foo':"bar"});
     $json->allow_singlequote->decode({'foo':'bar'});
 
 As same as the C<relaxed> option, this option may be used to parse
 application-specific files written by humans.
 
 =head2 allow_barekey
 
     $json = $json->allow_barekey([$enable])
 
 If C<$enable> is true (or missing), then C<decode> will accept
 bare keys of JSON object that are invalid JSON format.
 
 As same as the C<relaxed> option, this option may be used to parse
 application-specific files written by humans.
 
     $json->allow_barekey->decode('{foo:"bar"}');
 
 =head2 allow_bignum
 
     $json = $json->allow_bignum([$enable])
 
 If C<$enable> is true (or missing), then C<decode> will convert
 the big integer Perl cannot handle as integer into a L<Math::BigInt>
 object and convert a floating number (any) into a L<Math::BigFloat>.
 
 On the contrary, C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat>
 objects into JSON numbers with C<allow_blessed> enable.
 
    $json->allow_nonref->allow_blessed->allow_bignum;
    $bigfloat = $json->decode('2.000000000000000000000000001');
    print $json->encode($bigfloat);
    # => 2.000000000000000000000000001
 
 See to L<MAPPING> about the conversion of JSON number.
 
 =head2 loose
 
     $json = $json->loose([$enable])
 
 The unescaped [\x00-\x1f\x22\x2f\x5c] strings are invalid in JSON strings
 and the module doesn't allow to C<decode> to these (except for \x2f).
 If C<$enable> is true (or missing), then C<decode>  will accept these
 unescaped strings.
 
     $json->loose->decode(qq|["abc
                                    def"]|);
 
 See to L<JSON::PP/JSON::PP OWN METHODS>.
 
 =head2 escape_slash
 
     $json = $json->escape_slash([$enable])
 
 According to JSON Grammar, I<slash> (U+002F) is escaped. But by default
 JSON backend modules encode strings without escaping slash.
 
 If C<$enable> is true (or missing), then C<encode> will escape slashes.
 
 =head2 indent_length
 
     $json = $json->indent_length($length)
 
 With JSON::XS, The indent space length is 3 and cannot be changed.
 With JSON::PP, it sets the indent space length with the given $length.
 The default is 3. The acceptable range is 0 to 15.
 
 =head2 sort_by
 
     $json = $json->sort_by($function_name)
     $json = $json->sort_by($subroutine_ref)
 
 If $function_name or $subroutine_ref are set, its sort routine are used.
 
    $js = $pc->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })->encode($obj);
    # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|);
 
    $js = $pc->sort_by('own_sort')->encode($obj);
    # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|);
 
    sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b }
 
 As the sorting routine runs in the JSON::PP scope, the given
 subroutine name and the special variables C<$a>, C<$b> will begin
 with 'JSON::PP::'.
 
 If $integer is set, then the effect is same as C<canonical> on.
 
 See to L<JSON::PP/JSON::PP OWN METHODS>.
 
 =head1 MAPPING
 
 This section is copied from JSON::XS and modified to C<JSON>.
 JSON::XS and JSON::PP mapping mechanisms are almost equivalent.
 
 See to L<JSON::XS/MAPPING>.
 
 =head2 JSON -> PERL
 
 =over 4
 
 =item object
 
 A JSON object becomes a reference to a hash in Perl. No ordering of object
 keys is preserved (JSON does not preserver object key ordering itself).
 
 =item array
 
 A JSON array becomes a reference to an array in Perl.
 
 =item string
 
 A JSON string becomes a string scalar in Perl - Unicode codepoints in JSON
 are represented by the same codepoints in the Perl string, so no manual
 decoding is necessary.
 
 =item number
 
 A JSON number becomes either an integer, numeric (floating point) or
 string scalar in perl, depending on its range and any fractional parts. On
 the Perl level, there is no difference between those as Perl handles all
 the conversion details, but an integer may take slightly less memory and
 might represent more values exactly than floating point numbers.
 
 If the number consists of digits only, C<JSON> will try to represent
 it as an integer value. If that fails, it will try to represent it as
 a numeric (floating point) value if that is possible without loss of
 precision. Otherwise it will preserve the number as a string value (in
 which case you lose roundtripping ability, as the JSON number will be
 re-encoded to a JSON string).
 
 Numbers containing a fractional or exponential part will always be
 represented as numeric (floating point) values, possibly at a loss of
 precision (in which case you might lose perfect roundtripping ability, but
 the JSON number will still be re-encoded as a JSON number).
 
 Note that precision is not accuracy - binary floating point values cannot
 represent most decimal fractions exactly, and when converting from and to
 floating point, C<JSON> only guarantees precision up to but not including
 the least significant bit.
 
 If the backend is JSON::PP and C<allow_bignum> is enable, the big integers 
 and the numeric can be optionally converted into L<Math::BigInt> and
 L<Math::BigFloat> objects.
 
 =item true, false
 
 These JSON atoms become C<JSON::true> and C<JSON::false>,
 respectively. They are overloaded to act almost exactly like the numbers
 C<1> and C<0>. You can check whether a scalar is a JSON boolean by using
 the C<JSON::is_bool> function.
 
    print JSON::true + 1;
     => 1
 
    ok(JSON::true eq  '1');
    ok(JSON::true == 1);
 
 C<JSON> will install these missing overloading features to the backend modules.
 
 
 =item null
 
 A JSON null atom becomes C<undef> in Perl.
 
 C<JSON::null> returns C<undef>.
 
 =back
 
 
 =head2 PERL -> JSON
 
 The mapping from Perl to JSON is slightly more difficult, as Perl is a
 truly typeless language, so we can only guess which JSON type is meant by
 a Perl value.
 
 =over 4
 
 =item hash references
 
 Perl hash references become JSON objects. As there is no inherent ordering
 in hash keys (or JSON objects), they will usually be encoded in a
 pseudo-random order that can change between runs of the same program but
 stays generally the same within a single run of a program. C<JSON>
 optionally sort the hash keys (determined by the I<canonical> flag), so
 the same data structure will serialise to the same JSON text (given same
 settings and version of JSON::XS), but this incurs a runtime overhead
 and is only rarely useful, e.g. when you want to compare some JSON text
 against another for equality.
 
 In future, the ordered object feature will be added to JSON::PP using C<tie> mechanism.
 
 
 =item array references
 
 Perl array references become JSON arrays.
 
 =item other references
 
 Other unblessed references are generally not allowed and will cause an
 exception to be thrown, except for references to the integers C<0> and
 C<1>, which get turned into C<false> and C<true> atoms in JSON. You can
 also use C<JSON::false> and C<JSON::true> to improve readability.
 
    to_json [\0,JSON::true]      # yields [false,true]
 
 =item JSON::true, JSON::false, JSON::null
 
 These special values become JSON true and JSON false values,
 respectively. You can also use C<\1> and C<\0> directly if you want.
 
 JSON::null returns C<undef>.
 
 =item blessed objects
 
 Blessed objects are not directly representable in JSON. See the
 C<allow_blessed> and C<convert_blessed> methods on various options on
 how to deal with this: basically, you can choose between throwing an
 exception, encoding the reference as if it weren't blessed, or provide
 your own serialiser method.
 
 With C<convert_blessed_universally> mode,  C<encode> converts blessed
 hash references or blessed array references (contains other blessed references)
 into JSON members and arrays.
 
    use JSON -convert_blessed_universally;
    JSON->new->allow_blessed->convert_blessed->encode( $blessed_object );
 
 See to L<convert_blessed>.
 
 =item simple scalars
 
 Simple Perl scalars (any scalar that is not a reference) are the most
 difficult objects to encode: JSON::XS and JSON::PP will encode undefined scalars as
 JSON C<null> values, scalars that have last been used in a string context
 before encoding as JSON strings, and anything else as number value:
 
    # dump as number
    encode_json [2]                      # yields [2]
    encode_json [-3.0e17]                # yields [-3e+17]
    my $value = 5; encode_json [$value]  # yields [5]
 
    # used as string, so dump as string
    print $value;
    encode_json [$value]                 # yields ["5"]
 
    # undef becomes null
    encode_json [undef]                  # yields [null]
 
 You can force the type to be a string by stringifying it:
 
    my $x = 3.1; # some variable containing a number
    "$x";        # stringified
    $x .= "";    # another, more awkward way to stringify
    print $x;    # perl does it for you, too, quite often
 
 You can force the type to be a number by numifying it:
 
    my $x = "3"; # some variable containing a string
    $x += 0;     # numify it, ensuring it will be dumped as a number
    $x *= 1;     # same thing, the choice is yours.
 
 You can not currently force the type in other, less obscure, ways.
 
 Note that numerical precision has the same meaning as under Perl (so
 binary to decimal conversion follows the same rules as in Perl, which
 can differ to other languages). Also, your perl interpreter might expose
 extensions to the floating point numbers of your platform, such as
 infinities or NaN's - these cannot be represented in JSON, and it is an
 error to pass those in.
 
 =item Big Number
 
 If the backend is JSON::PP and C<allow_bignum> is enable, 
 C<encode> converts C<Math::BigInt> objects and C<Math::BigFloat>
 objects into JSON numbers.
 
 
 =back
 
 =head1 JSON and ECMAscript
 
 See to L<JSON::XS/JSON and ECMAscript>.
 
 =head1 JSON and YAML
 
 JSON is not a subset of YAML.
 See to L<JSON::XS/JSON and YAML>.
 
 
 =head1 BACKEND MODULE DECISION
 
 When you use C<JSON>, C<JSON> tries to C<use> JSON::XS. If this call failed, it will
 C<uses> JSON::PP. The required JSON::XS version is I<2.2> or later.
 
 The C<JSON> constructor method returns an object inherited from the backend module,
 and JSON::XS object is a blessed scalar reference while JSON::PP is a blessed hash
 reference.
 
 So, your program should not depend on the backend module, especially
 returned objects should not be modified.
 
  my $json = JSON->new; # XS or PP?
  $json->{stash} = 'this is xs object'; # this code may raise an error!
 
 To check the backend module, there are some methods - C<backend>, C<is_pp> and C<is_xs>.
 
   JSON->backend; # 'JSON::XS' or 'JSON::PP'
   
   JSON->backend->is_pp: # 0 or 1
   
   JSON->backend->is_xs: # 1 or 0
   
   $json->is_xs; # 1 or 0
   
   $json->is_pp; # 0 or 1
 
 
 If you set an environment variable C<PERL_JSON_BACKEND>, the calling action will be changed.
 
 =over
 
 =item PERL_JSON_BACKEND = 0 or PERL_JSON_BACKEND = 'JSON::PP'
 
 Always use JSON::PP
 
 =item PERL_JSON_BACKEND == 1 or PERL_JSON_BACKEND = 'JSON::XS,JSON::PP'
 
 (The default) Use compiled JSON::XS if it is properly compiled & installed,
 otherwise use JSON::PP.
 
 =item PERL_JSON_BACKEND == 2 or PERL_JSON_BACKEND = 'JSON::XS'
 
 Always use compiled JSON::XS, die if it isn't properly compiled & installed.
 
 =item PERL_JSON_BACKEND = 'JSON::backportPP'
 
 Always use JSON::backportPP.
 JSON::backportPP is JSON::PP back port module.
 C<JSON> includes JSON::backportPP instead of JSON::PP.
 
 =back
 
 These ideas come from L<DBI::PurePerl> mechanism.
 
 example:
 
  BEGIN { $ENV{PERL_JSON_BACKEND} = 'JSON::PP' }
  use JSON; # always uses JSON::PP
 
 In future, it may be able to specify another module.
 
 =head1 USE PP FEATURES EVEN THOUGH XS BACKEND
 
 Many methods are available with either JSON::XS or JSON::PP and
 when the backend module is JSON::XS, if any JSON::PP specific (i.e. JSON::XS unsupported)
 method is called, it will C<warn> and be noop.
 
 But If you C<use> C<JSON> passing the optional string C<-support_by_pp>,
 it makes a part of those unsupported methods available.
 This feature is achieved by using JSON::PP in C<de/encode>.
 
    BEGIN { $ENV{PERL_JSON_BACKEND} = 2 } # with JSON::XS
    use JSON -support_by_pp;
    my $json = JSON->new;
    $json->allow_nonref->escape_slash->encode("/");
 
 At this time, the returned object is a C<JSON::Backend::XS::Supportable>
 object (re-blessed XS object), and  by checking JSON::XS unsupported flags
 in de/encoding, can support some unsupported methods - C<loose>, C<allow_bignum>,
 C<allow_barekey>, C<allow_singlequote>, C<escape_slash> and C<indent_length>.
 
 When any unsupported methods are not enable, C<XS de/encode> will be
 used as is. The switch is achieved by changing the symbolic tables.
 
 C<-support_by_pp> is effective only when the backend module is JSON::XS
 and it makes the de/encoding speed down a bit.
 
 See to L<JSON::PP SUPPORT METHODS>.
 
 =head1 INCOMPATIBLE CHANGES TO OLD VERSION
 
 There are big incompatibility between new version (2.00) and old (1.xx).
 If you use old C<JSON> 1.xx in your code, please check it.
 
 See to L<Transition ways from 1.xx to 2.xx.>
 
 =over
 
 =item jsonToObj and objToJson are obsoleted.
 
 Non Perl-style name C<jsonToObj> and C<objToJson> are obsoleted
 (but not yet deleted from the source).
 If you use these functions in your code, please replace them
 with C<from_json> and C<to_json>.
 
 
 =item Global variables are no longer available.
 
 C<JSON> class variables - C<$JSON::AUTOCONVERT>, C<$JSON::BareKey>, etc...
 - are not available any longer.
 Instead, various features can be used through object methods.
 
 
 =item Package JSON::Converter and JSON::Parser are deleted.
 
 Now C<JSON> bundles with JSON::PP which can handle JSON more properly than them.
 
 =item Package JSON::NotString is deleted.
 
 There was C<JSON::NotString> class which represents JSON value C<true>, C<false>, C<null>
 and numbers. It was deleted and replaced by C<JSON::Boolean>.
 
 C<JSON::Boolean> represents C<true> and C<false>.
 
 C<JSON::Boolean> does not represent C<null>.
 
 C<JSON::null> returns C<undef>.
 
 C<JSON> makes L<JSON::XS::Boolean> and L<JSON::PP::Boolean> is-a relation
 to L<JSON::Boolean>.
 
 =item function JSON::Number is obsoleted.
 
 C<JSON::Number> is now needless because JSON::XS and JSON::PP have
 round-trip integrity.
 
 =item JSONRPC modules are deleted.
 
 Perl implementation of JSON-RPC protocol - C<JSONRPC >, C<JSONRPC::Transport::HTTP>
 and C<Apache::JSONRPC > are deleted in this distribution.
 Instead of them, there is L<JSON::RPC> which supports JSON-RPC protocol version 1.1.
 
 =back
 
 =head2 Transition ways from 1.xx to 2.xx.
 
 You should set C<suport_by_pp> mode firstly, because
 it is always successful for the below codes even with JSON::XS.
 
     use JSON -support_by_pp;
 
 =over
 
 =item Exported jsonToObj (simple)
 
   from_json($json_text);
 
 =item Exported objToJson (simple)
 
   to_json($perl_scalar);
 
 =item Exported jsonToObj (advanced)
 
   $flags = {allow_barekey => 1, allow_singlequote => 1};
   from_json($json_text, $flags);
 
 equivalent to:
 
   $JSON::BareKey = 1;
   $JSON::QuotApos = 1;
   jsonToObj($json_text);
 
 =item Exported objToJson (advanced)
 
   $flags = {allow_blessed => 1, allow_barekey => 1};
   to_json($perl_scalar, $flags);
 
 equivalent to:
 
   $JSON::BareKey = 1;
   objToJson($perl_scalar);
 
 =item jsonToObj as object method
 
   $json->decode($json_text);
 
 =item objToJson as object method
 
   $json->encode($perl_scalar);
 
 =item new method with parameters
 
 The C<new> method in 2.x takes any parameters no longer.
 You can set parameters instead;
 
    $json = JSON->new->pretty;
 
 =item $JSON::Pretty, $JSON::Indent, $JSON::Delimiter
 
 If C<indent> is enable, that means C<$JSON::Pretty> flag set. And
 C<$JSON::Delimiter> was substituted by C<space_before> and C<space_after>.
 In conclusion:
 
    $json->indent->space_before->space_after;
 
 Equivalent to:
 
   $json->pretty;
 
 To change indent length, use C<indent_length>.
 
 (Only with JSON::PP, if C<-support_by_pp> is not used.)
 
   $json->pretty->indent_length(2)->encode($perl_scalar);
 
 =item $JSON::BareKey
 
 (Only with JSON::PP, if C<-support_by_pp> is not used.)
 
   $json->allow_barekey->decode($json_text)
 
 =item $JSON::ConvBlessed
 
 use C<-convert_blessed_universally>. See to L<convert_blessed>.
 
 =item $JSON::QuotApos
 
 (Only with JSON::PP, if C<-support_by_pp> is not used.)
 
   $json->allow_singlequote->decode($json_text)
 
 =item $JSON::SingleQuote
 
 Disable. C<JSON> does not make such a invalid JSON string any longer.
 
 =item $JSON::KeySort
 
   $json->canonical->encode($perl_scalar)
 
 This is the ascii sort.
 
 If you want to use with your own sort routine, check the C<sort_by> method.
 
 (Only with JSON::PP, even if C<-support_by_pp> is used currently.)
 
   $json->sort_by($sort_routine_ref)->encode($perl_scalar)
  
   $json->sort_by(sub { $JSON::PP::a <=> $JSON::PP::b })->encode($perl_scalar)
 
 Can't access C<$a> and C<$b> but C<$JSON::PP::a> and C<$JSON::PP::b>.
 
 =item $JSON::SkipInvalid
 
   $json->allow_unknown
 
 =item $JSON::AUTOCONVERT
 
 Needless. C<JSON> backend modules have the round-trip integrity.
 
 =item $JSON::UTF8
 
 Needless because C<JSON> (JSON::XS/JSON::PP) sets
 the UTF8 flag on properly.
 
     # With UTF8-flagged strings
 
     $json->allow_nonref;
     $str = chr(1000); # UTF8-flagged
 
     $json_text  = $json->utf8(0)->encode($str);
     utf8::is_utf8($json_text);
     # true
     $json_text  = $json->utf8(1)->encode($str);
     utf8::is_utf8($json_text);
     # false
 
     $str = '"' . chr(1000) . '"'; # UTF8-flagged
 
     $perl_scalar  = $json->utf8(0)->decode($str);
     utf8::is_utf8($perl_scalar);
     # true
     $perl_scalar  = $json->utf8(1)->decode($str);
     # died because of 'Wide character in subroutine'
 
 See to L<JSON::XS/A FEW NOTES ON UNICODE AND PERL>.
 
 =item $JSON::UnMapping
 
 Disable. See to L<MAPPING>.
 
 =item $JSON::SelfConvert
 
 This option was deleted.
 Instead of it, if a given blessed object has the C<TO_JSON> method,
 C<TO_JSON> will be executed with C<convert_blessed>.
 
   $json->convert_blessed->encode($blessed_hashref_or_arrayref)
   # if need, call allow_blessed
 
 Note that it was C<toJson> in old version, but now not C<toJson> but C<TO_JSON>.
 
 =back
 
 =head1 TODO
 
 =over
 
 =item example programs
 
 =back
 
 =head1 THREADS
 
 No test with JSON::PP. If with JSON::XS, See to L<JSON::XS/THREADS>.
 
 
 =head1 BUGS
 
 Please report bugs relevant to C<JSON> to E<lt>makamaka[at]cpan.orgE<gt>.
 
 
 =head1 SEE ALSO
 
 Most of the document is copied and modified from JSON::XS doc.
 
 L<JSON::XS>, L<JSON::PP>
 
 C<RFC4627>(L<http://www.ietf.org/rfc/rfc4627.txt>)
 
 =head1 AUTHOR
 
 Makamaka Hannyaharamitu, E<lt>makamaka[at]cpan.orgE<gt>
 
 JSON::XS was written by  Marc Lehmann <schmorp[at]schmorp.de>
 
 The release of this new version owes to the courtesy of Marc Lehmann.
 
 
 =head1 COPYRIGHT AND LICENSE
 
 Copyright 2005-2013 by Makamaka Hannyaharamitu
 
 This library is free software; you can redistribute it and/or modify
 it under the same terms as Perl itself. 
 
 =cut
 
### JSON/Color.pm ###
 package JSON::Color;
 
 use 5.010001;
 use strict;
 use warnings;
 
 our $sul_available = eval { require Scalar::Util::LooksLikeNumber; 1 } ? 1:0;
 use Term::ANSIColor qw(:constants);
 
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(encode_json);
 
 our $VERSION = '0.08'; 
 
 our %theme = (
     start_quote         => BOLD . BRIGHT_GREEN,
     end_quote           => RESET,
     start_string        => GREEN,
     end_string          => RESET,
     start_string_escape => BOLD,
     end_string_escape   => RESET . GREEN, 
     start_number        => BOLD . BRIGHT_MAGENTA,
     end_number          => RESET,
     start_bool          => CYAN,
     end_bool            => RESET,
     start_null          => CYAN,
     end_null            => RESET,
     start_object_key    => MAGENTA,
     end_object_key      => RESET,
     start_object_key_escape => BOLD,
     end_object_key_escape   => RESET . MAGENTA, 
     start_linum         => REVERSE . WHITE,
     end_linum           => RESET,
 );
 
 my %esc = (
     "\n" => '\n',
     "\r" => '\r',
     "\t" => '\t',
     "\f" => '\f',
     "\b" => '\b',
     "\"" => '\"',
     "\\" => '\\\\',
     "\'" => '\\\'',
 );
 sub _string {
     my ($value, $opts) = @_;
 
     my ($sq, $eq, $ss, $es, $sse, $ese);
     if ($opts->{obj_key}) {
         $sq  = $theme{start_object_key};
         $eq  = $theme{end_object_key};
         $ss  = $theme{start_object_key};
         $es  = $theme{end_object_key};
         $sse = $theme{start_object_key_escape};
         $ese = $theme{end_object_key_escape};
     } else {
         $sq  = $theme{start_quote};
         $eq  = $theme{end_quote};
         $ss  = $theme{start_string};
         $es  = $theme{end_string};
         $sse = $theme{start_string_escape};
         $ese = $theme{end_string_escape};
     }
 
     $value =~ s/([\x22\x5c\n\r\t\f\b])|([\x00-\x08\x0b\x0e-\x1f])/
         join("",
              $sse,
              $1 ? $esc{$1} : '\\u00' . unpack('H2', $2),
              $ese,
          )
             /eg;
 
     return join(
         "",
         $sq, '"', $eq,
         $ss, $value, $es,
         $sq, '"', $eq,
     );
 }
 
 sub _number {
     my ($value, $opts) = @_;
 
     return join(
         "",
         $theme{start_number}, $value, $theme{end_number},
     );
 }
 
 sub _null {
     my ($value, $opts) = @_;
 
     return join(
         "",
         $theme{start_null}, "null", $theme{end_null},
     );
 }
 
 sub _bool {
     my ($value, $opts) = @_;
 
     return join(
         "",
         $theme{start_bool}, "$value", $theme{end_bool},
     );
 }
 
 sub _array {
     my ($value, $opts) = @_;
 
     return "[]" unless @$value;
     my $indent  = $opts->{pretty} ? "   " x  $opts->{_indent}    : "";
     my $indent2 = $opts->{pretty} ? "   " x ($opts->{_indent}+1) : "";
     my $nl      = $opts->{pretty} ? "\n" : "";
     local $opts->{_indent} = $opts->{_indent}+1;
     return join(
         "",
         "[$nl",
         (map {
             $indent2,
             _encode($value->[$_], $opts),
             $_ == @$value-1 ? $nl : ",$nl",
         } 0..@$value-1),
         $indent, "]",
     );
 }
 
 sub _hash {
     my ($value, $opts) = @_;
 
     return "{}" unless keys %$value;
     my $indent  = $opts->{pretty} ? "   " x  $opts->{_indent}    : "";
     my $indent2 = $opts->{pretty} ? "   " x ($opts->{_indent}+1) : "";
     my $nl      = $opts->{pretty} ? "\n" : "";
     my $colon   = $opts->{pretty} ? ": " : ":";
     my @res;
 
     push @res, "{$nl";
     my @k = sort keys(%$value);
     local $opts->{_indent} = $opts->{_indent}+1;
     for (0..@k-1) {
         my $k = $k[$_];
         push @res, (
             $indent2,
             _string($k, {obj_key=>1}),
             $colon,
             _encode($value->{$k}, $opts),
             $_ == @k-1 ? $nl : ",$nl",
         );
     }
     push @res, $indent, "}";
     join "", @res;
 }
 
 sub _encode {
     my ($data, $opts) = @_;
 
     my $ref = ref($data);
 
     if (!defined($data)) {
         return _null($data, $opts);
     } elsif ($ref eq 'ARRAY') {
         return _array($data, $opts);
     } elsif ($ref eq 'HASH') {
         return _hash($data, $opts);
     } elsif ($ref eq 'JSON::XS::Boolean' || $ref eq 'JSON::PP::Boolean') {
         return _bool($data, $opts);
     } elsif (!$ref) {
         if ($sul_available &&
                 Scalar::Util::LooksLikeNumber::looks_like_number($data) =~
                   /^(4|12|4352|8704)$/o) {
             return _number($data, $opts);
         } else {
             return _string($data, $opts);
         }
     } else {
         die "Can't encode $data";
     }
 }
 
 sub encode_json {
     my ($value, $opts) = @_;
     $opts //= {};
     $opts->{_indent} //= 0;
     my $res = _encode($value , $opts);
 
     if ($opts->{linum}) {
         my $lines = 0;
         $lines++ while $res =~ /^/mog;
         my $fmt = "%".length($lines)."d";
         my $i = 0;
         $res =~ s/^/
             $theme{start_linum} . sprintf($fmt, ++$i) . $theme{end_linum}
                 /meg;
     }
     $res;
 }
 
 1;
 
 __END__
 
### JSON/PP.pm ###
 package JSON::PP;
 
 
 use 5.005;
 use strict;
 use base qw(Exporter);
 use overload ();
 
 use Carp ();
 use B ();
 
 $JSON::PP::VERSION = '2.27300';
 
 @JSON::PP::EXPORT = qw(encode_json decode_json from_json to_json);
 
 
 use constant P_ASCII                => 0;
 use constant P_LATIN1               => 1;
 use constant P_UTF8                 => 2;
 use constant P_INDENT               => 3;
 use constant P_CANONICAL            => 4;
 use constant P_SPACE_BEFORE         => 5;
 use constant P_SPACE_AFTER          => 6;
 use constant P_ALLOW_NONREF         => 7;
 use constant P_SHRINK               => 8;
 use constant P_ALLOW_BLESSED        => 9;
 use constant P_CONVERT_BLESSED      => 10;
 use constant P_RELAXED              => 11;
 
 use constant P_LOOSE                => 12;
 use constant P_ALLOW_BIGNUM         => 13;
 use constant P_ALLOW_BAREKEY        => 14;
 use constant P_ALLOW_SINGLEQUOTE    => 15;
 use constant P_ESCAPE_SLASH         => 16;
 use constant P_AS_NONBLESSED        => 17;
 
 use constant P_ALLOW_UNKNOWN        => 18;
 
 use constant OLD_PERL => $] < 5.008 ? 1 : 0;
 
 BEGIN {
     my @xs_compati_bit_properties = qw(
             latin1 ascii utf8 indent canonical space_before space_after allow_nonref shrink
             allow_blessed convert_blessed relaxed allow_unknown
     );
     my @pp_bit_properties = qw(
             allow_singlequote allow_bignum loose
             allow_barekey escape_slash as_nonblessed
     );
 
     if ($] < 5.008 ) {
         my $helper = $] >= 5.006 ? 'JSON::PP::Compat5006' : 'JSON::PP::Compat5005';
         eval qq| require $helper |;
         if ($@) { Carp::croak $@; }
     }
 
     for my $name (@xs_compati_bit_properties, @pp_bit_properties) {
         my $flag_name = 'P_' . uc($name);
 
         eval qq/
             sub $name {
                 my \$enable = defined \$_[1] ? \$_[1] : 1;
 
                 if (\$enable) {
                     \$_[0]->{PROPS}->[$flag_name] = 1;
                 }
                 else {
                     \$_[0]->{PROPS}->[$flag_name] = 0;
                 }
 
                 \$_[0];
             }
 
             sub get_$name {
                 \$_[0]->{PROPS}->[$flag_name] ? 1 : '';
             }
         /;
     }
 
 }
 
 
 
 
 my %encode_allow_method
      = map {($_ => 1)} qw/utf8 pretty allow_nonref latin1 self_encode escape_slash
                           allow_blessed convert_blessed indent indent_length allow_bignum
                           as_nonblessed
                         /;
 my %decode_allow_method
      = map {($_ => 1)} qw/utf8 allow_nonref loose allow_singlequote allow_bignum
                           allow_barekey max_size relaxed/;
 
 
 my $JSON; 
 
 sub encode_json ($) { 
     ($JSON ||= __PACKAGE__->new->utf8)->encode(@_);
 }
 
 
 sub decode_json { 
     ($JSON ||= __PACKAGE__->new->utf8)->decode(@_);
 }
 
 
 sub to_json($) {
    Carp::croak ("JSON::PP::to_json has been renamed to encode_json.");
 }
 
 
 sub from_json($) {
    Carp::croak ("JSON::PP::from_json has been renamed to decode_json.");
 }
 
 
 
 sub new {
     my $class = shift;
     my $self  = {
         max_depth   => 512,
         max_size    => 0,
         indent      => 0,
         FLAGS       => 0,
         fallback      => sub { encode_error('Invalid value. JSON can only reference.') },
         indent_length => 3,
     };
 
     bless $self, $class;
 }
 
 
 sub encode {
     return $_[0]->PP_encode_json($_[1]);
 }
 
 
 sub decode {
     return $_[0]->PP_decode_json($_[1], 0x00000000);
 }
 
 
 sub decode_prefix {
     return $_[0]->PP_decode_json($_[1], 0x00000001);
 }
 
 
 
 
 
 sub pretty {
     my ($self, $v) = @_;
     my $enable = defined $v ? $v : 1;
 
     if ($enable) { 
         $self->indent(1)->indent_length(3)->space_before(1)->space_after(1);
     }
     else {
         $self->indent(0)->space_before(0)->space_after(0);
     }
 
     $self;
 }
 
 
 sub max_depth {
     my $max  = defined $_[1] ? $_[1] : 0x80000000;
     $_[0]->{max_depth} = $max;
     $_[0];
 }
 
 
 sub get_max_depth { $_[0]->{max_depth}; }
 
 
 sub max_size {
     my $max  = defined $_[1] ? $_[1] : 0;
     $_[0]->{max_size} = $max;
     $_[0];
 }
 
 
 sub get_max_size { $_[0]->{max_size}; }
 
 
 sub filter_json_object {
     $_[0]->{cb_object} = defined $_[1] ? $_[1] : 0;
     $_[0]->{F_HOOK} = ($_[0]->{cb_object} or $_[0]->{cb_sk_object}) ? 1 : 0;
     $_[0];
 }
 
 sub filter_json_single_key_object {
     if (@_ > 1) {
         $_[0]->{cb_sk_object}->{$_[1]} = $_[2];
     }
     $_[0]->{F_HOOK} = ($_[0]->{cb_object} or $_[0]->{cb_sk_object}) ? 1 : 0;
     $_[0];
 }
 
 sub indent_length {
     if (!defined $_[1] or $_[1] > 15 or $_[1] < 0) {
         Carp::carp "The acceptable range of indent_length() is 0 to 15.";
     }
     else {
         $_[0]->{indent_length} = $_[1];
     }
     $_[0];
 }
 
 sub get_indent_length {
     $_[0]->{indent_length};
 }
 
 sub sort_by {
     $_[0]->{sort_by} = defined $_[1] ? $_[1] : 1;
     $_[0];
 }
 
 sub allow_bigint {
     Carp::carp("allow_bigint() is obsoleted. use allow_bignum() insted.");
 }
 
 
 
 
 { 
 
     my $max_depth;
     my $indent;
     my $ascii;
     my $latin1;
     my $utf8;
     my $space_before;
     my $space_after;
     my $canonical;
     my $allow_blessed;
     my $convert_blessed;
 
     my $indent_length;
     my $escape_slash;
     my $bignum;
     my $as_nonblessed;
 
     my $depth;
     my $indent_count;
     my $keysort;
 
 
     sub PP_encode_json {
         my $self = shift;
         my $obj  = shift;
 
         $indent_count = 0;
         $depth        = 0;
 
         my $idx = $self->{PROPS};
 
         ($ascii, $latin1, $utf8, $indent, $canonical, $space_before, $space_after, $allow_blessed,
             $convert_blessed, $escape_slash, $bignum, $as_nonblessed)
          = @{$idx}[P_ASCII .. P_SPACE_AFTER, P_ALLOW_BLESSED, P_CONVERT_BLESSED,
                     P_ESCAPE_SLASH, P_ALLOW_BIGNUM, P_AS_NONBLESSED];
 
         ($max_depth, $indent_length) = @{$self}{qw/max_depth indent_length/};
 
         $keysort = $canonical ? sub { $a cmp $b } : undef;
 
         if ($self->{sort_by}) {
             $keysort = ref($self->{sort_by}) eq 'CODE' ? $self->{sort_by}
                      : $self->{sort_by} =~ /\D+/       ? $self->{sort_by}
                      : sub { $a cmp $b };
         }
 
         encode_error("hash- or arrayref expected (not a simple scalar, use allow_nonref to allow this)")
              if(!ref $obj and !$idx->[ P_ALLOW_NONREF ]);
 
         my $str  = $self->object_to_json($obj);
 
         $str .= "\n" if ( $indent ); 
 
         unless ($ascii or $latin1 or $utf8) {
             utf8::upgrade($str);
         }
 
         if ($idx->[ P_SHRINK ]) {
             utf8::downgrade($str, 1);
         }
 
         return $str;
     }
 
 
     sub object_to_json {
         my ($self, $obj) = @_;
         my $type = ref($obj);
 
         if($type eq 'HASH'){
             return $self->hash_to_json($obj);
         }
         elsif($type eq 'ARRAY'){
             return $self->array_to_json($obj);
         }
         elsif ($type) { 
             if (blessed($obj)) {
 
                 return $self->value_to_json($obj) if ( $obj->isa('JSON::PP::Boolean') );
 
                 if ( $convert_blessed and $obj->can('TO_JSON') ) {
                     my $result = $obj->TO_JSON();
                     if ( defined $result and ref( $result ) ) {
                         if ( refaddr( $obj ) eq refaddr( $result ) ) {
                             encode_error( sprintf(
                                 "%s::TO_JSON method returned same object as was passed instead of a new one",
                                 ref $obj
                             ) );
                         }
                     }
 
                     return $self->object_to_json( $result );
                 }
 
                 return "$obj" if ( $bignum and _is_bignum($obj) );
                 return $self->blessed_to_json($obj) if ($allow_blessed and $as_nonblessed); 
 
                 encode_error( sprintf("encountered object '%s', but neither allow_blessed "
                     . "nor convert_blessed settings are enabled", $obj)
                 ) unless ($allow_blessed);
 
                 return 'null';
             }
             else {
                 return $self->value_to_json($obj);
             }
         }
         else{
             return $self->value_to_json($obj);
         }
     }
 
 
     sub hash_to_json {
         my ($self, $obj) = @_;
         my @res;
 
         encode_error("json text or perl structure exceeds maximum nesting level (max_depth set too low?)")
                                          if (++$depth > $max_depth);
 
         my ($pre, $post) = $indent ? $self->_up_indent() : ('', '');
         my $del = ($space_before ? ' ' : '') . ':' . ($space_after ? ' ' : '');
 
         for my $k ( _sort( $obj ) ) {
             if ( OLD_PERL ) { utf8::decode($k) } 
             push @res, string_to_json( $self, $k )
                           .  $del
                           . ( $self->object_to_json( $obj->{$k} ) || $self->value_to_json( $obj->{$k} ) );
         }
 
         --$depth;
         $self->_down_indent() if ($indent);
 
         return   '{' . ( @res ? $pre : '' ) . ( @res ? join( ",$pre", @res ) . $post : '' )  . '}';
     }
 
 
     sub array_to_json {
         my ($self, $obj) = @_;
         my @res;
 
         encode_error("json text or perl structure exceeds maximum nesting level (max_depth set too low?)")
                                          if (++$depth > $max_depth);
 
         my ($pre, $post) = $indent ? $self->_up_indent() : ('', '');
 
         for my $v (@$obj){
             push @res, $self->object_to_json($v) || $self->value_to_json($v);
         }
 
         --$depth;
         $self->_down_indent() if ($indent);
 
         return '[' . ( @res ? $pre : '' ) . ( @res ? join( ",$pre", @res ) . $post : '' ) . ']';
     }
 
 
     sub value_to_json {
         my ($self, $value) = @_;
 
         return 'null' if(!defined $value);
 
         my $b_obj = B::svref_2object(\$value);  
         my $flags = $b_obj->FLAGS;
 
         return $value 
             if $flags & ( B::SVp_IOK | B::SVp_NOK ) and !( $flags & B::SVp_POK ); 
 
         my $type = ref($value);
 
         if(!$type){
             return string_to_json($self, $value);
         }
         elsif( blessed($value) and  $value->isa('JSON::PP::Boolean') ){
             return $$value == 1 ? 'true' : 'false';
         }
         elsif ($type) {
             if ((overload::StrVal($value) =~ /=(\w+)/)[0]) {
                 return $self->value_to_json("$value");
             }
 
             if ($type eq 'SCALAR' and defined $$value) {
                 return   $$value eq '1' ? 'true'
                        : $$value eq '0' ? 'false'
                        : $self->{PROPS}->[ P_ALLOW_UNKNOWN ] ? 'null'
                        : encode_error("cannot encode reference to scalar");
             }
 
              if ( $self->{PROPS}->[ P_ALLOW_UNKNOWN ] ) {
                  return 'null';
              }
              else {
                  if ( $type eq 'SCALAR' or $type eq 'REF' ) {
                     encode_error("cannot encode reference to scalar");
                  }
                  else {
                     encode_error("encountered $value, but JSON can only represent references to arrays or hashes");
                  }
              }
 
         }
         else {
             return $self->{fallback}->($value)
                  if ($self->{fallback} and ref($self->{fallback}) eq 'CODE');
             return 'null';
         }
 
     }
 
 
     my %esc = (
         "\n" => '\n',
         "\r" => '\r',
         "\t" => '\t',
         "\f" => '\f',
         "\b" => '\b',
         "\"" => '\"',
         "\\" => '\\\\',
         "\'" => '\\\'',
     );
 
 
     sub string_to_json {
         my ($self, $arg) = @_;
 
         $arg =~ s/([\x22\x5c\n\r\t\f\b])/$esc{$1}/g;
         $arg =~ s/\//\\\//g if ($escape_slash);
         $arg =~ s/([\x00-\x08\x0b\x0e-\x1f])/'\\u00' . unpack('H2', $1)/eg;
 
         if ($ascii) {
             $arg = JSON_PP_encode_ascii($arg);
         }
 
         if ($latin1) {
             $arg = JSON_PP_encode_latin1($arg);
         }
 
         if ($utf8) {
             utf8::encode($arg);
         }
 
         return '"' . $arg . '"';
     }
 
 
     sub blessed_to_json {
         my $reftype = reftype($_[1]) || '';
         if ($reftype eq 'HASH') {
             return $_[0]->hash_to_json($_[1]);
         }
         elsif ($reftype eq 'ARRAY') {
             return $_[0]->array_to_json($_[1]);
         }
         else {
             return 'null';
         }
     }
 
 
     sub encode_error {
         my $error  = shift;
         Carp::croak "$error";
     }
 
 
     sub _sort {
         defined $keysort ? (sort $keysort (keys %{$_[0]})) : keys %{$_[0]};
     }
 
 
     sub _up_indent {
         my $self  = shift;
         my $space = ' ' x $indent_length;
 
         my ($pre,$post) = ('','');
 
         $post = "\n" . $space x $indent_count;
 
         $indent_count++;
 
         $pre = "\n" . $space x $indent_count;
 
         return ($pre,$post);
     }
 
 
     sub _down_indent { $indent_count--; }
 
 
     sub PP_encode_box {
         {
             depth        => $depth,
             indent_count => $indent_count,
         };
     }
 
 } 
 
 
 sub _encode_ascii {
     join('',
         map {
             $_ <= 127 ?
                 chr($_) :
             $_ <= 65535 ?
                 sprintf('\u%04x', $_) : sprintf('\u%x\u%x', _encode_surrogates($_));
         } unpack('U*', $_[0])
     );
 }
 
 
 sub _encode_latin1 {
     join('',
         map {
             $_ <= 255 ?
                 chr($_) :
             $_ <= 65535 ?
                 sprintf('\u%04x', $_) : sprintf('\u%x\u%x', _encode_surrogates($_));
         } unpack('U*', $_[0])
     );
 }
 
 
 sub _encode_surrogates { 
     my $uni = $_[0] - 0x10000;
     return ($uni / 0x400 + 0xD800, $uni % 0x400 + 0xDC00);
 }
 
 
 sub _is_bignum {
     $_[0]->isa('Math::BigInt') or $_[0]->isa('Math::BigFloat');
 }
 
 
 
 
 my $max_intsize;
 
 BEGIN {
     my $checkint = 1111;
     for my $d (5..64) {
         $checkint .= 1;
         my $int   = eval qq| $checkint |;
         if ($int =~ /[eE]/) {
             $max_intsize = $d - 1;
             last;
         }
     }
 }
 
 { 
 
     my %escapes = ( 
         b    => "\x8",
         t    => "\x9",
         n    => "\xA",
         f    => "\xC",
         r    => "\xD",
         '\\' => '\\',
         '"'  => '"',
         '/'  => '/',
     );
 
     my $text; 
     my $at;   
     my $ch;   
     my $len;  
     my $depth;          
     my $encoding;       
     my $is_valid_utf8;  
     my $utf8_len;       
     my $utf8;           
     my $max_depth;      
     my $max_size;
     my $relaxed;
     my $cb_object;
     my $cb_sk_object;
 
     my $F_HOOK;
 
     my $allow_bigint;   
     my $singlequote;    
     my $loose;          
     my $allow_barekey;  
 
 
     sub PP_decode_json {
         my ($self, $opt); 
 
         ($self, $text, $opt) = @_;
 
         ($at, $ch, $depth) = (0, '', 0);
 
         if ( !defined $text or ref $text ) {
             decode_error("malformed JSON string, neither array, object, number, string or atom");
         }
 
         my $idx = $self->{PROPS};
 
         ($utf8, $relaxed, $loose, $allow_bigint, $allow_barekey, $singlequote)
             = @{$idx}[P_UTF8, P_RELAXED, P_LOOSE .. P_ALLOW_SINGLEQUOTE];
 
         if ( $utf8 ) {
             utf8::downgrade( $text, 1 ) or Carp::croak("Wide character in subroutine entry");
         }
         else {
             utf8::upgrade( $text );
             utf8::encode( $text );
         }
 
         $len = length $text;
 
         ($max_depth, $max_size, $cb_object, $cb_sk_object, $F_HOOK)
              = @{$self}{qw/max_depth  max_size cb_object cb_sk_object F_HOOK/};
 
         if ($max_size > 1) {
             use bytes;
             my $bytes = length $text;
             decode_error(
                 sprintf("attempted decode of JSON text of %s bytes size, but max_size is set to %s"
                     , $bytes, $max_size), 1
             ) if ($bytes > $max_size);
         }
 
         my @octets = unpack('C4', $text);
         $encoding =   ( $octets[0] and  $octets[1]) ? 'UTF-8'
                     : (!$octets[0] and  $octets[1]) ? 'UTF-16BE'
                     : (!$octets[0] and !$octets[1]) ? 'UTF-32BE'
                     : ( $octets[2]                ) ? 'UTF-16LE'
                     : (!$octets[2]                ) ? 'UTF-32LE'
                     : 'unknown';
 
         white(); 
 
         my $valid_start = defined $ch; 
 
         my $result = value();
 
         return undef if ( !$result && ( $opt & 0x10000000 ) ); 
 
         decode_error("malformed JSON string, neither array, object, number, string or atom") unless $valid_start;
 
         if ( !$idx->[ P_ALLOW_NONREF ] and !ref $result ) {
                 decode_error(
                 'JSON text must be an object or array (but found number, string, true, false or null,'
                        . ' use allow_nonref to allow this)', 1);
         }
 
         Carp::croak('something wrong.') if $len < $at; 
 
         my $consumed = defined $ch ? $at - 1 : $at; 
 
         white(); 
 
         if ( $ch ) {
             return ( $result, $consumed ) if ($opt & 0x00000001); 
             decode_error("garbage after JSON object");
         }
 
         ( $opt & 0x00000001 ) ? ( $result, $consumed ) : $result;
     }
 
 
     sub next_chr {
         return $ch = undef if($at >= $len);
         $ch = substr($text, $at++, 1);
     }
 
 
     sub value {
         white();
         return          if(!defined $ch);
         return object() if($ch eq '{');
         return array()  if($ch eq '[');
         return string() if($ch eq '"' or ($singlequote and $ch eq "'"));
         return number() if($ch =~ /[0-9]/ or $ch eq '-');
         return word();
     }
 
     sub string {
         my ($i, $s, $t, $u);
         my $utf16;
         my $is_utf8;
 
         ($is_valid_utf8, $utf8_len) = ('', 0);
 
         $s = ''; 
 
         if($ch eq '"' or ($singlequote and $ch eq "'")){
             my $boundChar = $ch;
 
             OUTER: while( defined(next_chr()) ){
 
                 if($ch eq $boundChar){
                     next_chr();
 
                     if ($utf16) {
                         decode_error("missing low surrogate character in surrogate pair");
                     }
 
                     utf8::decode($s) if($is_utf8);
 
                     return $s;
                 }
                 elsif($ch eq '\\'){
                     next_chr();
                     if(exists $escapes{$ch}){
                         $s .= $escapes{$ch};
                     }
                     elsif($ch eq 'u'){ 
                         my $u = '';
 
                         for(1..4){
                             $ch = next_chr();
                             last OUTER if($ch !~ /[0-9a-fA-F]/);
                             $u .= $ch;
                         }
 
                         if ($u =~ /^[dD][89abAB][0-9a-fA-F]{2}/) { 
                             $utf16 = $u;
                         }
                         elsif ($u =~ /^[dD][c-fC-F][0-9a-fA-F]{2}/) { 
                             unless (defined $utf16) {
                                 decode_error("missing high surrogate character in surrogate pair");
                             }
                             $is_utf8 = 1;
                             $s .= JSON_PP_decode_surrogates($utf16, $u) || next;
                             $utf16 = undef;
                         }
                         else {
                             if (defined $utf16) {
                                 decode_error("surrogate pair expected");
                             }
 
                             if ( ( my $hex = hex( $u ) ) > 127 ) {
                                 $is_utf8 = 1;
                                 $s .= JSON_PP_decode_unicode($u) || next;
                             }
                             else {
                                 $s .= chr $hex;
                             }
                         }
 
                     }
                     else{
                         unless ($loose) {
                             $at -= 2;
                             decode_error('illegal backslash escape sequence in string');
                         }
                         $s .= $ch;
                     }
                 }
                 else{
 
                     if ( ord $ch  > 127 ) {
                         unless( $ch = is_valid_utf8($ch) ) {
                             $at -= 1;
                             decode_error("malformed UTF-8 character in JSON string");
                         }
                         else {
                             $at += $utf8_len - 1;
                         }
 
                         $is_utf8 = 1;
                     }
 
                     if (!$loose) {
                         if ($ch =~ /[\x00-\x1f\x22\x5c]/)  { 
                             $at--;
                             decode_error('invalid character encountered while parsing JSON string');
                         }
                     }
 
                     $s .= $ch;
                 }
             }
         }
 
         decode_error("unexpected end of string while parsing JSON string");
     }
 
 
     sub white {
         while( defined $ch  ){
             if($ch le ' '){
                 next_chr();
             }
             elsif($ch eq '/'){
                 next_chr();
                 if(defined $ch and $ch eq '/'){
                     1 while(defined(next_chr()) and $ch ne "\n" and $ch ne "\r");
                 }
                 elsif(defined $ch and $ch eq '*'){
                     next_chr();
                     while(1){
                         if(defined $ch){
                             if($ch eq '*'){
                                 if(defined(next_chr()) and $ch eq '/'){
                                     next_chr();
                                     last;
                                 }
                             }
                             else{
                                 next_chr();
                             }
                         }
                         else{
                             decode_error("Unterminated comment");
                         }
                     }
                     next;
                 }
                 else{
                     $at--;
                     decode_error("malformed JSON string, neither array, object, number, string or atom");
                 }
             }
             else{
                 if ($relaxed and $ch eq '#') { 
                     pos($text) = $at;
                     $text =~ /\G([^\n]*(?:\r\n|\r|\n|$))/g;
                     $at = pos($text);
                     next_chr;
                     next;
                 }
 
                 last;
             }
         }
     }
 
 
     sub array {
         my $a  = $_[0] || []; 
 
         decode_error('json text or perl structure exceeds maximum nesting level (max_depth set too low?)')
                                                     if (++$depth > $max_depth);
 
         next_chr();
         white();
 
         if(defined $ch and $ch eq ']'){
             --$depth;
             next_chr();
             return $a;
         }
         else {
             while(defined($ch)){
                 push @$a, value();
 
                 white();
 
                 if (!defined $ch) {
                     last;
                 }
 
                 if($ch eq ']'){
                     --$depth;
                     next_chr();
                     return $a;
                 }
 
                 if($ch ne ','){
                     last;
                 }
 
                 next_chr();
                 white();
 
                 if ($relaxed and $ch eq ']') {
                     --$depth;
                     next_chr();
                     return $a;
                 }
 
             }
         }
 
         decode_error(", or ] expected while parsing array");
     }
 
 
     sub object {
         my $o = $_[0] || {}; 
         my $k;
 
         decode_error('json text or perl structure exceeds maximum nesting level (max_depth set too low?)')
                                                 if (++$depth > $max_depth);
         next_chr();
         white();
 
         if(defined $ch and $ch eq '}'){
             --$depth;
             next_chr();
             if ($F_HOOK) {
                 return _json_object_hook($o);
             }
             return $o;
         }
         else {
             while (defined $ch) {
                 $k = ($allow_barekey and $ch ne '"' and $ch ne "'") ? bareKey() : string();
                 white();
 
                 if(!defined $ch or $ch ne ':'){
                     $at--;
                     decode_error("':' expected");
                 }
 
                 next_chr();
                 $o->{$k} = value();
                 white();
 
                 last if (!defined $ch);
 
                 if($ch eq '}'){
                     --$depth;
                     next_chr();
                     if ($F_HOOK) {
                         return _json_object_hook($o);
                     }
                     return $o;
                 }
 
                 if($ch ne ','){
                     last;
                 }
 
                 next_chr();
                 white();
 
                 if ($relaxed and $ch eq '}') {
                     --$depth;
                     next_chr();
                     if ($F_HOOK) {
                         return _json_object_hook($o);
                     }
                     return $o;
                 }
 
             }
 
         }
 
         $at--;
         decode_error(", or } expected while parsing object/hash");
     }
 
 
     sub bareKey { 
         my $key;
         while($ch =~ /[^\x00-\x23\x25-\x2F\x3A-\x40\x5B-\x5E\x60\x7B-\x7F]/){
             $key .= $ch;
             next_chr();
         }
         return $key;
     }
 
 
     sub word {
         my $word =  substr($text,$at-1,4);
 
         if($word eq 'true'){
             $at += 3;
             next_chr;
             return $JSON::PP::true;
         }
         elsif($word eq 'null'){
             $at += 3;
             next_chr;
             return undef;
         }
         elsif($word eq 'fals'){
             $at += 3;
             if(substr($text,$at,1) eq 'e'){
                 $at++;
                 next_chr;
                 return $JSON::PP::false;
             }
         }
 
         $at--; 
 
         decode_error("'null' expected")  if ($word =~ /^n/);
         decode_error("'true' expected")  if ($word =~ /^t/);
         decode_error("'false' expected") if ($word =~ /^f/);
         decode_error("malformed JSON string, neither array, object, number, string or atom");
     }
 
 
     sub number {
         my $n    = '';
         my $v;
 
         if($ch eq '0'){
             my $peek = substr($text,$at,1);
             my $hex  = $peek =~ /[xX]/; 
 
             if($hex){
                 decode_error("malformed number (leading zero must not be followed by another digit)");
                 ($n) = ( substr($text, $at+1) =~ /^([0-9a-fA-F]+)/);
             }
             else{ 
                 ($n) = ( substr($text, $at) =~ /^([0-7]+)/);
                 if (defined $n and length $n > 1) {
                     decode_error("malformed number (leading zero must not be followed by another digit)");
                 }
             }
 
             if(defined $n and length($n)){
                 if (!$hex and length($n) == 1) {
                    decode_error("malformed number (leading zero must not be followed by another digit)");
                 }
                 $at += length($n) + $hex;
                 next_chr;
                 return $hex ? hex($n) : oct($n);
             }
         }
 
         if($ch eq '-'){
             $n = '-';
             next_chr;
             if (!defined $ch or $ch !~ /\d/) {
                 decode_error("malformed number (no digits after initial minus)");
             }
         }
 
         while(defined $ch and $ch =~ /\d/){
             $n .= $ch;
             next_chr;
         }
 
         if(defined $ch and $ch eq '.'){
             $n .= '.';
 
             next_chr;
             if (!defined $ch or $ch !~ /\d/) {
                 decode_error("malformed number (no digits after decimal point)");
             }
             else {
                 $n .= $ch;
             }
 
             while(defined(next_chr) and $ch =~ /\d/){
                 $n .= $ch;
             }
         }
 
         if(defined $ch and ($ch eq 'e' or $ch eq 'E')){
             $n .= $ch;
             next_chr;
 
             if(defined($ch) and ($ch eq '+' or $ch eq '-')){
                 $n .= $ch;
                 next_chr;
                 if (!defined $ch or $ch =~ /\D/) {
                     decode_error("malformed number (no digits after exp sign)");
                 }
                 $n .= $ch;
             }
             elsif(defined($ch) and $ch =~ /\d/){
                 $n .= $ch;
             }
             else {
                 decode_error("malformed number (no digits after exp sign)");
             }
 
             while(defined(next_chr) and $ch =~ /\d/){
                 $n .= $ch;
             }
 
         }
 
         $v .= $n;
 
         if ($v !~ /[.eE]/ and length $v > $max_intsize) {
             if ($allow_bigint) { 
                 require Math::BigInt;
                 return Math::BigInt->new($v);
             }
             else {
                 return "$v";
             }
         }
         elsif ($allow_bigint) {
             require Math::BigFloat;
             return Math::BigFloat->new($v);
         }
 
         return 0+$v;
     }
 
 
     sub is_valid_utf8 {
 
         $utf8_len = $_[0] =~ /[\x00-\x7F]/  ? 1
                   : $_[0] =~ /[\xC2-\xDF]/  ? 2
                   : $_[0] =~ /[\xE0-\xEF]/  ? 3
                   : $_[0] =~ /[\xF0-\xF4]/  ? 4
                   : 0
                   ;
 
         return unless $utf8_len;
 
         my $is_valid_utf8 = substr($text, $at - 1, $utf8_len);
 
         return ( $is_valid_utf8 =~ /^(?:
              [\x00-\x7F]
             |[\xC2-\xDF][\x80-\xBF]
             |[\xE0][\xA0-\xBF][\x80-\xBF]
             |[\xE1-\xEC][\x80-\xBF][\x80-\xBF]
             |[\xED][\x80-\x9F][\x80-\xBF]
             |[\xEE-\xEF][\x80-\xBF][\x80-\xBF]
             |[\xF0][\x90-\xBF][\x80-\xBF][\x80-\xBF]
             |[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]
             |[\xF4][\x80-\x8F][\x80-\xBF][\x80-\xBF]
         )$/x )  ? $is_valid_utf8 : '';
     }
 
 
     sub decode_error {
         my $error  = shift;
         my $no_rep = shift;
         my $str    = defined $text ? substr($text, $at) : '';
         my $mess   = '';
         my $type   = $] >= 5.008           ? 'U*'
                    : $] <  5.006           ? 'C*'
                    : utf8::is_utf8( $str ) ? 'U*' 
                    : 'C*'
                    ;
 
         for my $c ( unpack( $type, $str ) ) { 
             $mess .=  $c == 0x07 ? '\a'
                     : $c == 0x09 ? '\t'
                     : $c == 0x0a ? '\n'
                     : $c == 0x0d ? '\r'
                     : $c == 0x0c ? '\f'
                     : $c <  0x20 ? sprintf('\x{%x}', $c)
                     : $c == 0x5c ? '\\\\'
                     : $c <  0x80 ? chr($c)
                     : sprintf('\x{%x}', $c)
                     ;
             if ( length $mess >= 20 ) {
                 $mess .= '...';
                 last;
             }
         }
 
         unless ( length $mess ) {
             $mess = '(end of string)';
         }
 
         Carp::croak (
             $no_rep ? "$error" : "$error, at character offset $at (before \"$mess\")"
         );
 
     }
 
 
     sub _json_object_hook {
         my $o    = $_[0];
         my @ks = keys %{$o};
 
         if ( $cb_sk_object and @ks == 1 and exists $cb_sk_object->{ $ks[0] } and ref $cb_sk_object->{ $ks[0] } ) {
             my @val = $cb_sk_object->{ $ks[0] }->( $o->{$ks[0]} );
             if (@val == 1) {
                 return $val[0];
             }
         }
 
         my @val = $cb_object->($o) if ($cb_object);
         if (@val == 0 or @val > 1) {
             return $o;
         }
         else {
             return $val[0];
         }
     }
 
 
     sub PP_decode_box {
         {
             text    => $text,
             at      => $at,
             ch      => $ch,
             len     => $len,
             depth   => $depth,
             encoding      => $encoding,
             is_valid_utf8 => $is_valid_utf8,
         };
     }
 
 } 
 
 
 sub _decode_surrogates { 
     my $uni = 0x10000 + (hex($_[0]) - 0xD800) * 0x400 + (hex($_[1]) - 0xDC00);
     my $un  = pack('U*', $uni);
     utf8::encode( $un );
     return $un;
 }
 
 
 sub _decode_unicode {
     my $un = pack('U', hex shift);
     utf8::encode( $un );
     return $un;
 }
 
 
 BEGIN {
 
     unless ( defined &utf8::is_utf8 ) {
        require Encode;
        *utf8::is_utf8 = *Encode::is_utf8;
     }
 
     if ( $] >= 5.008 ) {
         *JSON::PP::JSON_PP_encode_ascii      = \&_encode_ascii;
         *JSON::PP::JSON_PP_encode_latin1     = \&_encode_latin1;
         *JSON::PP::JSON_PP_decode_surrogates = \&_decode_surrogates;
         *JSON::PP::JSON_PP_decode_unicode    = \&_decode_unicode;
     }
 
     if ($] >= 5.008 and $] < 5.008003) { 
         package JSON::PP;
         require subs;
         subs->import('join');
         eval q|
             sub join {
                 return '' if (@_ < 2);
                 my $j   = shift;
                 my $str = shift;
                 for (@_) { $str .= $j . $_; }
                 return $str;
             }
         |;
     }
 
 
     sub JSON::PP::incr_parse {
         local $Carp::CarpLevel = 1;
         ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_parse( @_ );
     }
 
 
     sub JSON::PP::incr_skip {
         ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_skip;
     }
 
 
     sub JSON::PP::incr_reset {
         ( $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new )->incr_reset;
     }
 
     eval q{
         sub JSON::PP::incr_text : lvalue {
             $_[0]->{_incr_parser} ||= JSON::PP::IncrParser->new;
 
             if ( $_[0]->{_incr_parser}->{incr_parsing} ) {
                 Carp::croak("incr_text can not be called when the incremental parser already started parsing");
             }
             $_[0]->{_incr_parser}->{incr_text};
         }
     } if ( $] >= 5.006 );
 
 } 
 
 
 
 BEGIN {
     eval 'require Scalar::Util';
     unless($@){
         *JSON::PP::blessed = \&Scalar::Util::blessed;
         *JSON::PP::reftype = \&Scalar::Util::reftype;
         *JSON::PP::refaddr = \&Scalar::Util::refaddr;
     }
     else{ 
         eval 'sub UNIVERSAL::a_sub_not_likely_to_be_here { ref($_[0]) }';
         *JSON::PP::blessed = sub {
             local($@, $SIG{__DIE__}, $SIG{__WARN__});
             ref($_[0]) ? eval { $_[0]->a_sub_not_likely_to_be_here } : undef;
         };
         my %tmap = qw(
             B::NULL   SCALAR
             B::HV     HASH
             B::AV     ARRAY
             B::CV     CODE
             B::IO     IO
             B::GV     GLOB
             B::REGEXP REGEXP
         );
         *JSON::PP::reftype = sub {
             my $r = shift;
 
             return undef unless length(ref($r));
 
             my $t = ref(B::svref_2object($r));
 
             return
                 exists $tmap{$t} ? $tmap{$t}
               : length(ref($$r)) ? 'REF'
               :                    'SCALAR';
         };
         *JSON::PP::refaddr = sub {
           return undef unless length(ref($_[0]));
 
           my $addr;
           if(defined(my $pkg = blessed($_[0]))) {
             $addr .= bless $_[0], 'Scalar::Util::Fake';
             bless $_[0], $pkg;
           }
           else {
             $addr .= $_[0]
           }
 
           $addr =~ /0x(\w+)/;
           local $^W;
           hex($1);
         }
     }
 }
 
 
 
 $JSON::PP::true  = do { bless \(my $dummy = 1), "JSON::PP::Boolean" };
 $JSON::PP::false = do { bless \(my $dummy = 0), "JSON::PP::Boolean" };
 
 sub is_bool { defined $_[0] and UNIVERSAL::isa($_[0], "JSON::PP::Boolean"); }
 
 sub true  { $JSON::PP::true  }
 sub false { $JSON::PP::false }
 sub null  { undef; }
 
 
 package JSON::PP::Boolean;
 
 use overload (
    "0+"     => sub { ${$_[0]} },
    "++"     => sub { $_[0] = ${$_[0]} + 1 },
    "--"     => sub { $_[0] = ${$_[0]} - 1 },
    fallback => 1,
 );
 
 
 
 package JSON::PP::IncrParser;
 
 use strict;
 
 use constant INCR_M_WS   => 0; 
 use constant INCR_M_STR  => 1; 
 use constant INCR_M_BS   => 2; 
 use constant INCR_M_JSON => 3; 
 use constant INCR_M_C0   => 4;
 use constant INCR_M_C1   => 5;
 
 $JSON::PP::IncrParser::VERSION = '1.01';
 
 my $unpack_format = $] < 5.006 ? 'C*' : 'U*';
 
 sub new {
     my ( $class ) = @_;
 
     bless {
         incr_nest    => 0,
         incr_text    => undef,
         incr_parsing => 0,
         incr_p       => 0,
     }, $class;
 }
 
 
 sub incr_parse {
     my ( $self, $coder, $text ) = @_;
 
     $self->{incr_text} = '' unless ( defined $self->{incr_text} );
 
     if ( defined $text ) {
         if ( utf8::is_utf8( $text ) and !utf8::is_utf8( $self->{incr_text} ) ) {
             utf8::upgrade( $self->{incr_text} ) ;
             utf8::decode( $self->{incr_text} ) ;
         }
         $self->{incr_text} .= $text;
     }
 
 
     my $max_size = $coder->get_max_size;
 
     if ( defined wantarray ) {
 
         $self->{incr_mode} = INCR_M_WS unless defined $self->{incr_mode};
 
         if ( wantarray ) {
             my @ret;
 
             $self->{incr_parsing} = 1;
 
             do {
                 push @ret, $self->_incr_parse( $coder, $self->{incr_text} );
 
                 unless ( !$self->{incr_nest} and $self->{incr_mode} == INCR_M_JSON ) {
                     $self->{incr_mode} = INCR_M_WS if $self->{incr_mode} != INCR_M_STR;
                 }
 
             } until ( length $self->{incr_text} >= $self->{incr_p} );
 
             $self->{incr_parsing} = 0;
 
             return @ret;
         }
         else { 
             $self->{incr_parsing} = 1;
             my $obj = $self->_incr_parse( $coder, $self->{incr_text} );
             $self->{incr_parsing} = 0 if defined $obj; 
             return $obj ? $obj : undef; 
         }
 
     }
 
 }
 
 
 sub _incr_parse {
     my ( $self, $coder, $text, $skip ) = @_;
     my $p = $self->{incr_p};
     my $restore = $p;
 
     my @obj;
     my $len = length $text;
 
     if ( $self->{incr_mode} == INCR_M_WS ) {
         while ( $len > $p ) {
             my $s = substr( $text, $p, 1 );
             $p++ and next if ( 0x20 >= unpack($unpack_format, $s) );
             $self->{incr_mode} = INCR_M_JSON;
             last;
        }
     }
 
     while ( $len > $p ) {
         my $s = substr( $text, $p++, 1 );
 
         if ( $s eq '"' ) {
             if (substr( $text, $p - 2, 1 ) eq '\\' ) {
                 next;
             }
 
             if ( $self->{incr_mode} != INCR_M_STR  ) {
                 $self->{incr_mode} = INCR_M_STR;
             }
             else {
                 $self->{incr_mode} = INCR_M_JSON;
                 unless ( $self->{incr_nest} ) {
                     last;
                 }
             }
         }
 
         if ( $self->{incr_mode} == INCR_M_JSON ) {
 
             if ( $s eq '[' or $s eq '{' ) {
                 if ( ++$self->{incr_nest} > $coder->get_max_depth ) {
                     Carp::croak('json text or perl structure exceeds maximum nesting level (max_depth set too low?)');
                 }
             }
             elsif ( $s eq ']' or $s eq '}' ) {
                 last if ( --$self->{incr_nest} <= 0 );
             }
             elsif ( $s eq '#' ) {
                 while ( $len > $p ) {
                     last if substr( $text, $p++, 1 ) eq "\n";
                 }
             }
 
         }
 
     }
 
     $self->{incr_p} = $p;
 
     return if ( $self->{incr_mode} == INCR_M_STR and not $self->{incr_nest} );
     return if ( $self->{incr_mode} == INCR_M_JSON and $self->{incr_nest} > 0 );
 
     return '' unless ( length substr( $self->{incr_text}, 0, $p ) );
 
     local $Carp::CarpLevel = 2;
 
     $self->{incr_p} = $restore;
     $self->{incr_c} = $p;
 
     my ( $obj, $tail ) = $coder->PP_decode_json( substr( $self->{incr_text}, 0, $p ), 0x10000001 );
 
     $self->{incr_text} = substr( $self->{incr_text}, $p );
     $self->{incr_p} = 0;
 
     return $obj || '';
 }
 
 
 sub incr_text {
     if ( $_[0]->{incr_parsing} ) {
         Carp::croak("incr_text can not be called when the incremental parser already started parsing");
     }
     $_[0]->{incr_text};
 }
 
 
 sub incr_skip {
     my $self  = shift;
     $self->{incr_text} = substr( $self->{incr_text}, $self->{incr_c} );
     $self->{incr_p} = 0;
 }
 
 
 sub incr_reset {
     my $self = shift;
     $self->{incr_text}    = undef;
     $self->{incr_p}       = 0;
     $self->{incr_mode}    = 0;
     $self->{incr_nest}    = 0;
     $self->{incr_parsing} = 0;
 }
 
 
 
 1;
 __END__
### JSON/PP/Boolean.pm ###
 
 use JSON::PP ();
 use strict;
 
 1;
 
 
### LWP.pm ###
 package LWP;
 
 $VERSION = "6.13";
 sub Version { $VERSION; }
 
 require 5.008;
 require LWP::UserAgent;  
 
 1;
 
 __END__
 
### LWP/Authen/Basic.pm ###
 package LWP::Authen::Basic;
 use strict;
 
 require MIME::Base64;
 
 sub auth_header {
     my($class, $user, $pass) = @_;
     return "Basic " . MIME::Base64::encode("$user:$pass", "");
 }
 
 sub authenticate
 {
     my($class, $ua, $proxy, $auth_param, $response,
        $request, $arg, $size) = @_;
 
     my $realm = $auth_param->{realm} || "";
     my $url = $proxy ? $request->{proxy} : $request->uri_canonical;
     return $response unless $url;
     my $host_port = $url->host_port;
     my $auth_header = $proxy ? "Proxy-Authorization" : "Authorization";
 
     my @m = $proxy ? (m_proxy => $url) : (m_host_port => $host_port);
     push(@m, realm => $realm);
 
     my $h = $ua->get_my_handler("request_prepare", @m, sub {
         $_[0]{callback} = sub {
             my($req, $ua, $h) = @_;
             my($user, $pass) = $ua->credentials($host_port, $h->{realm});
 	    if (defined $user) {
 		my $auth_value = $class->auth_header($user, $pass, $req, $ua, $h);
 		$req->header($auth_header => $auth_value);
 	    }
         };
     });
     $h->{auth_param} = $auth_param;
 
     if (!$proxy && !$request->header($auth_header) && $ua->credentials($host_port, $realm)) {
         add_path($h, $url->path);
         return $ua->request($request->clone, $arg, $size, $response);
     }
 
     my($user, $pass) = $ua->get_basic_credentials($realm, $url, $proxy);
     unless (defined $user and defined $pass) {
 	$ua->set_my_handler("request_prepare", undef, @m);  
 	return $response;
     }
 
     my ($olduser, $oldpass) = $ua->credentials($host_port, $realm);
     return $response if (defined $olduser and defined $oldpass and
                          $user eq $olduser and $pass eq $oldpass);
 
     $ua->credentials($host_port, $realm, $user, $pass);
     add_path($h, $url->path) unless $proxy;
     return $ua->request($request->clone, $arg, $size, $response);
 }
 
 sub add_path {
     my($h, $path) = @_;
     $path =~ s,[^/]+\z,,;
     push(@{$h->{m_path_prefix}}, $path);
 }
 
 1;
### LWP/Authen/Digest.pm ###
 package LWP::Authen::Digest;
 
 use strict;
 use base 'LWP::Authen::Basic';
 
 require Digest::MD5;
 
 sub auth_header {
     my($class, $user, $pass, $request, $ua, $h) = @_;
 
     my $auth_param = $h->{auth_param};
 
     my $nc = sprintf "%08X", ++$ua->{authen_md5_nonce_count}{$auth_param->{nonce}};
     my $cnonce = sprintf "%8x", time;
 
     my $uri = $request->uri->path_query;
     $uri = "/" unless length $uri;
 
     my $md5 = Digest::MD5->new;
 
     my(@digest);
     $md5->add(join(":", $user, $auth_param->{realm}, $pass));
     push(@digest, $md5->hexdigest);
     $md5->reset;
 
     push(@digest, $auth_param->{nonce});
 
     if ($auth_param->{qop}) {
 	push(@digest, $nc, $cnonce, ($auth_param->{qop} =~ m|^auth[,;]auth-int$|) ? 'auth' : $auth_param->{qop});
     }
 
     $md5->add(join(":", $request->method, $uri));
     push(@digest, $md5->hexdigest);
     $md5->reset;
 
     $md5->add(join(":", @digest));
     my($digest) = $md5->hexdigest;
     $md5->reset;
 
     my %resp = map { $_ => $auth_param->{$_} } qw(realm nonce opaque);
     @resp{qw(username uri response algorithm)} = ($user, $uri, $digest, "MD5");
 
     if (($auth_param->{qop} || "") =~ m|^auth([,;]auth-int)?$|) {
 	@resp{qw(qop cnonce nc)} = ("auth", $cnonce, $nc);
     }
 
     my(@order) = qw(username realm qop algorithm uri nonce nc cnonce response);
     if($request->method =~ /^(?:POST|PUT)$/) {
 	$md5->add($request->content);
 	my $content = $md5->hexdigest;
 	$md5->reset;
 	$md5->add(join(":", @digest[0..1], $content));
 	$md5->reset;
 	$resp{"message-digest"} = $md5->hexdigest;
 	push(@order, "message-digest");
     }
     push(@order, "opaque");
     my @pairs;
     for (@order) {
 	next unless defined $resp{$_};
 
 	if ( $_ eq 'qop' || $_ eq 'nc' ) {
 		push(@pairs, "$_=" . $resp{$_});
 	}
 	else {
 		push(@pairs, "$_=" . qq("$resp{$_}"));
 	}
     }
 
     my $auth_value  = "Digest " . join(", ", @pairs);
     return $auth_value;
 }
 
 1;
### LWP/Authen/Ntlm.pm ###
 package LWP::Authen::Ntlm;
 
 use strict;
 use vars qw/$VERSION/;
 
 $VERSION = "6.13";
 
 use Authen::NTLM "1.02";
 use MIME::Base64 "2.12";
 
 sub authenticate {
     my($class, $ua, $proxy, $auth_param, $response,
        $request, $arg, $size) = @_;
 
     my($user, $pass) = $ua->get_basic_credentials($auth_param->{realm},
                                                   $request->uri, $proxy);
 
     unless(defined $user and defined $pass) {
 		return $response;
 	}
 
 	if (!$ua->conn_cache()) {
 		warn "The keep_alive option must be enabled for NTLM authentication to work.  NTLM authentication aborted.\n";
 		return $response;
 	}
 
 	my($domain, $username) = split(/\\/, $user);
 
 	ntlm_domain($domain);
 	ntlm_user($username);
 	ntlm_password($pass);
 
     my $auth_header = $proxy ? "Proxy-Authorization" : "Authorization";
 
 	my $challenge;
 	foreach ($response->header('WWW-Authenticate')) { 
 		last if /^NTLM/ && ($challenge=$_);
 	}
 
 	if ($challenge eq 'NTLM') {
 	    my $auth_value = "NTLM " . ntlm();
 		ntlm_reset();
 
 	    my $r = $response;
 		my $retry_count = 0;
 	    while ($r) {
 			my $auth = $r->request->header($auth_header);
 			++$retry_count if ($auth && $auth eq $auth_value);
 			if ($retry_count > 2) {
 				    $response->header("Client-Warning" =>
 						      "Credentials for '$user' failed before");
 				    return $response;
 			}
 			$r = $r->previous;
 	    }
 
 	    my $referral = $request->clone;
 	    $referral->header($auth_header => $auth_value);
 	    return $ua->request($referral, $arg, $size, $response);
 	}
 	
 	else {
 		my $auth_value;
 		if ($response->code ne '401') {
 			return $response;
 		}
 		else {
 			my $challenge;
 			foreach ($response->header('WWW-Authenticate')) { 
 				last if /^NTLM/ && ($challenge=$_);
 			}
 			$challenge =~ s/^NTLM //;
 			ntlm();
 			$auth_value = "NTLM " . ntlm($challenge);
 			ntlm_reset();
 		}
 
 	    my $referral = $request->clone;
 	    $referral->header($auth_header => $auth_value);
 	    my $response2 = $ua->request($referral, $arg, $size, $response);
 		return $response2;
 	}
 }
 
 1;
 
 
### LWP/ConnCache.pm ###
 package LWP::ConnCache;
 
 use strict;
 use vars qw($VERSION $DEBUG);
 
 $VERSION = "6.13";
 
 
 sub new {
     my($class, %cnf) = @_;
 
     my $total_capacity = 1;
     if (exists $cnf{total_capacity}) {
         $total_capacity = delete $cnf{total_capacity};
     }
     if (%cnf && $^W) {
 	require Carp;
 	Carp::carp("Unrecognised options: @{[sort keys %cnf]}")
     }
     my $self = bless { cc_conns => [] }, $class;
     $self->total_capacity($total_capacity);
     $self;
 }
 
 
 sub deposit {
     my($self, $type, $key, $conn) = @_;
     push(@{$self->{cc_conns}}, [$conn, $type, $key, time]);
     $self->enforce_limits($type);
     return;
 }
 
 
 sub withdraw {
     my($self, $type, $key) = @_;
     my $conns = $self->{cc_conns};
     for my $i (0 .. @$conns - 1) {
 	my $c = $conns->[$i];
 	next unless $c->[1] eq $type && $c->[2] eq $key;
 	splice(@$conns, $i, 1);  
 	return $c->[0];
     }
     return undef;
 }
 
 
 sub total_capacity {
     my $self = shift;
     my $old = $self->{cc_limit_total};
     if (@_) {
 	$self->{cc_limit_total} = shift;
 	$self->enforce_limits;
     }
     $old;
 }
 
 
 sub capacity {
     my $self = shift;
     my $type = shift;
     my $old = $self->{cc_limit}{$type};
     if (@_) {
 	$self->{cc_limit}{$type} = shift;
 	$self->enforce_limits($type);
     }
     $old;
 }
 
 
 sub enforce_limits {
     my($self, $type) = @_;
     my $conns = $self->{cc_conns};
 
     my @types = $type ? ($type) : ($self->get_types);
     for $type (@types) {
 	next unless $self->{cc_limit};
 	my $limit = $self->{cc_limit}{$type};
 	next unless defined $limit;
 	for my $i (reverse 0 .. @$conns - 1) {
 	    next unless $conns->[$i][1] eq $type;
 	    if (--$limit < 0) {
 		$self->dropping(splice(@$conns, $i, 1), "$type capacity exceeded");
 	    }
 	}
     }
 
     if (defined(my $total = $self->{cc_limit_total})) {
 	while (@$conns > $total) {
 	    $self->dropping(shift(@$conns), "Total capacity exceeded");
 	}
     }
 }
 
 
 sub dropping {
     my($self, $c, $reason) = @_;
     print "DROPPING @$c [$reason]\n" if $DEBUG;
 }
 
 
 sub drop {
     my($self, $checker, $reason) = @_;
     if (ref($checker) ne "CODE") {
 	if (!defined $checker) {
 	    $checker = sub { 1 };  
 	}
 	elsif (_looks_like_number($checker)) {
 	    my $age_limit = $checker;
 	    my $time_limit = time - $age_limit;
 	    $reason ||= "older than $age_limit";
 	    $checker = sub { $_[3] < $time_limit };
 	}
 	else {
 	    my $type = $checker;
 	    $reason ||= "drop $type";
 	    $checker = sub { $_[1] eq $type };  
 	}
     }
     $reason ||= "drop";
 
     local $SIG{__DIE__};  
     local $@;
     my @c;
     for (@{$self->{cc_conns}}) {
 	my $drop;
 	eval {
 	    if (&$checker(@$_)) {
 		$self->dropping($_, $reason);
 		$drop++;
 	    }
 	};
 	push(@c, $_) unless $drop;
     }
     @{$self->{cc_conns}} = @c;
 }
 
 
 sub prune {
     my $self = shift;
     $self->drop(sub { !shift->ping }, "ping");
 }
 
 
 sub get_types {
     my $self = shift;
     my %t;
     $t{$_->[1]}++ for @{$self->{cc_conns}};
     return keys %t;
 }
 
 
 sub get_connections {
     my($self, $type) = @_;
     my @c;
     for (@{$self->{cc_conns}}) {
 	push(@c, $_->[0]) if !$type || ($type && $type eq $_->[1]);
     }
     @c;
 }
 
 
 sub _looks_like_number {
     $_[0] =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;
 }
 
 1;
 
 
 __END__
 
### LWP/Debug.pm ###
 package LWP::Debug;  
 
 require Exporter;
 @ISA = qw(Exporter);
 @EXPORT_OK = qw(level trace debug conns);
 
 use Carp ();
 
 my @levels = qw(trace debug conns);
 %current_level = ();
 
 
 sub import
 {
     my $pack = shift;
     my $callpkg = caller(0);
     my @symbols = ();
     my @levels = ();
     for (@_) {
 	if (/^[-+]/) {
 	    push(@levels, $_);
 	}
 	else {
 	    push(@symbols, $_);
 	}
     }
     Exporter::export($pack, $callpkg, @symbols);
     level(@levels);
 }
 
 
 sub level
 {
     for (@_) {
 	if ($_ eq '+') {              
 	    %current_level = map { $_ => 1 } @levels;
 	}
 	elsif ($_ eq '-') {           
 	    %current_level = ();
 	}
 	elsif (/^([-+])(\w+)$/) {
 	    $current_level{$2} = $1 eq '+';
 	}
 	else {
 	    Carp::croak("Illegal level format $_");
 	}
     }
 }
 
 
 sub trace  { _log(@_) if $current_level{'trace'}; }
 sub debug  { _log(@_) if $current_level{'debug'}; }
 sub conns  { _log(@_) if $current_level{'conns'}; }
 
 
 sub _log
 {
     my $msg = shift;
     $msg .= "\n" unless $msg =~ /\n$/;  
 
     my($package,$filename,$line,$sub) = caller(2);
     print STDERR "$sub: $msg";
 }
 
 1;
 
 __END__
 
### LWP/DebugFile.pm ###
 package LWP::DebugFile;
 
 
 1;
### LWP/MemberMixin.pm ###
 package LWP::MemberMixin;
 
 sub _elem
 {
     my $self = shift;
     my $elem = shift;
     my $old = $self->{$elem};
     $self->{$elem} = shift if @_;
     return $old;
 }
 
 1;
 
 __END__
 
### LWP/Protocol.pm ###
 package LWP::Protocol;
 
 require LWP::MemberMixin;
 @ISA = qw(LWP::MemberMixin);
 $VERSION = "6.13";
 
 use strict;
 use Carp ();
 use HTTP::Status ();
 use HTTP::Response;
 
 my %ImplementedBy = (); 
 
 
 
 sub new
 {
     my($class, $scheme, $ua) = @_;
 
     my $self = bless {
 	scheme => $scheme,
 	ua => $ua,
 
         max_size => $ua->{max_size},
     }, $class;
 
     $self;
 }
 
 
 sub create
 {
     my($scheme, $ua) = @_;
     my $impclass = LWP::Protocol::implementor($scheme) or
 	Carp::croak("Protocol scheme '$scheme' is not supported");
 
     my $protocol = $impclass->new($scheme, $ua);
 
     return $protocol;
 }
 
 
 sub implementor
 {
     my($scheme, $impclass) = @_;
 
     if ($impclass) {
 	$ImplementedBy{$scheme} = $impclass;
     }
     my $ic = $ImplementedBy{$scheme};
     return $ic if $ic;
 
     return '' unless $scheme =~ /^([.+\-\w]+)$/;  
     $scheme = $1; 
     $scheme =~ s/[.+\-]/_/g;  
 
     $ic = "LWP::Protocol::$scheme";  
     $ic = "LWP::Protocol::nntp" if $scheme eq 'news'; 
     no strict 'refs';
     unless (@{"${ic}::ISA"}) {
 	eval "require $ic";
 	if ($@) {
 	    if ($@ =~ /Can't locate/) { 
 		$ic = '';
 	    }
 	    else {
 		die "$@\n";
 	    }
 	}
     }
     $ImplementedBy{$scheme} = $ic if $ic;
     $ic;
 }
 
 
 sub request
 {
     my($self, $request, $proxy, $arg, $size, $timeout) = @_;
     Carp::croak('LWP::Protocol::request() needs to be overridden in subclasses');
 }
 
 
 sub timeout    { shift->_elem('timeout',    @_); }
 sub max_size   { shift->_elem('max_size',   @_); }
 
 
 sub collect
 {
     my ($self, $arg, $response, $collector) = @_;
     my $content;
     my($ua, $max_size) = @{$self}{qw(ua max_size)};
 
     eval {
 	local $\; 
         if (!defined($arg) || !$response->is_success) {
             $response->{default_add_content} = 1;
         }
         elsif (!ref($arg) && length($arg)) {
             open(my $fh, ">", $arg) or die "Can't write to '$arg': $!";
 	    binmode($fh);
             push(@{$response->{handlers}{response_data}}, {
                 callback => sub {
                     print $fh $_[3] or die "Can't write to '$arg': $!";
                     1;
                 },
             });
             push(@{$response->{handlers}{response_done}}, {
                 callback => sub {
 		    close($fh) or die "Can't write to '$arg': $!";
 		    undef($fh);
 		},
 	    });
         }
         elsif (ref($arg) eq 'CODE') {
             push(@{$response->{handlers}{response_data}}, {
                 callback => sub {
 		    &$arg($_[3], $_[0], $self);
 		    1;
                 },
             });
         }
         else {
             die "Unexpected collect argument '$arg'";
         }
 
         $ua->run_handlers("response_header", $response);
 
         if (delete $response->{default_add_content}) {
             push(@{$response->{handlers}{response_data}}, {
 		callback => sub {
 		    $_[0]->add_content($_[3]);
 		    1;
 		},
 	    });
         }
 
 
         my $content_size = 0;
         my $length = $response->content_length;
         my %skip_h;
 
         while ($content = &$collector, length $$content) {
             for my $h ($ua->handlers("response_data", $response)) {
                 next if $skip_h{$h};
                 unless ($h->{callback}->($response, $ua, $h, $$content)) {
                     $skip_h{$h}++;
                 }
             }
             $content_size += length($$content);
             $ua->progress(($length ? ($content_size / $length) : "tick"), $response);
             if (defined($max_size) && $content_size > $max_size) {
                 $response->push_header("Client-Aborted", "max_size");
                 last;
             }
         }
     };
     my $err = $@;
     delete $response->{handlers}{response_data};
     delete $response->{handlers} unless %{$response->{handlers}};
     if ($err) {
         chomp($err);
         $response->push_header('X-Died' => $err);
         $response->push_header("Client-Aborted", "die");
         return $response;
     }
 
     return $response;
 }
 
 
 sub collect_once
 {
     my($self, $arg, $response) = @_;
     my $content = \ $_[3];
     my $first = 1;
     $self->collect($arg, $response, sub {
 	return $content if $first--;
 	return \ "";
     });
 }
 
 1;
 
 
 __END__
 
### LWP/Protocol/GHTTP.pm ###
 package LWP::Protocol::GHTTP;
 
 
 use strict;
 use vars qw(@ISA);
 
 require LWP::Protocol;
 @ISA=qw(LWP::Protocol);
 
 require HTTP::Response;
 require HTTP::Status;
 
 use HTTP::GHTTP qw(METHOD_GET METHOD_HEAD METHOD_POST);
 
 my %METHOD =
 (
  GET  => METHOD_GET,
  HEAD => METHOD_HEAD,
  POST => METHOD_POST,
 );
 
 sub request
 {
     my($self, $request, $proxy, $arg, $size, $timeout) = @_;
 
     my $method = $request->method;
     unless (exists $METHOD{$method}) {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				   "Bad method '$method'");
     }
 
     my $r = HTTP::GHTTP->new($request->uri);
 
     $request->headers->scan(sub { $r->set_header(@_)});
 
     $r->set_type($METHOD{$method});
 
     my $cref = $request->content_ref;
     $r->set_body($$cref) if length($$cref);
 
     $r->set_proxy($proxy->as_string) if $proxy;
 
     $r->process_request;
 
     my $response = HTTP::Response->new($r->get_status);
 
     my @headers;
     eval {
 	@headers = $r->get_headers;
     };
     @headers = qw(Date Connection Server Content-type
                   Accept-Ranges Server
                   Content-Length Last-Modified ETag) if $@;
     for (@headers) {
 	my $v = $r->get_header($_);
 	$response->header($_ => $v) if defined $v;
     }
 
     return $self->collect_once($arg, $response, $r->get_body);
 }
 
 1;
### LWP/Protocol/cpan.pm ###
 package LWP::Protocol::cpan;
 
 use strict;
 use vars qw(@ISA);
 
 require LWP::Protocol;
 @ISA = qw(LWP::Protocol);
 
 require URI;
 require HTTP::Status;
 require HTTP::Response;
 
 our $CPAN;
 
 unless ($CPAN) {
     eval {
 	require CPAN::Config;
 	if($CPAN::Config) {
 	    my $urls = $CPAN::Config->{urllist};
 	    if (ref($urls) eq "ARRAY") {
 		my $file;
 		for (@$urls) {
 		    if (/^file:/) {
 			$file = $_;
 			last;
 		    }
 		}
 
 		if ($file) {
 		    $CPAN = $file;
 		}
 		else {
 		    $CPAN = $urls->[0];
 		}
 	    }
 	}
     };
 
     $CPAN ||= "http://cpan.org/";  
 }
 
 $CPAN .= "/" unless $CPAN =~ m,/$,;
 
 
 sub request {
     my($self, $request, $proxy, $arg, $size) = @_;
     if (defined $proxy)
     {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				   'You can not proxy with cpan');
     }
 
     my $method = $request->method;
     unless ($method eq 'GET' || $method eq 'HEAD') {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				   'Library does not allow method ' .
 				   "$method for 'cpan:' URLs");
     }
 
     my $path = $request->uri->path;
     $path =~ s,^/,,;
 
     my $response = HTTP::Response->new(&HTTP::Status::RC_FOUND);
     $response->header("Location" => URI->new_abs($path, $CPAN));
     $response;
 }
 
 1;
### LWP/Protocol/data.pm ###
 package LWP::Protocol::data;
 
 
 use strict;
 use vars qw(@ISA);
 
 require HTTP::Response;
 require HTTP::Status;
 
 require LWP::Protocol;
 @ISA = qw(LWP::Protocol);
 
 use HTTP::Date qw(time2str);
 require LWP;  
 
 sub request
 {
     my($self, $request, $proxy, $arg, $size) = @_;
 
     if (defined $proxy)
     {
 	return HTTP::Response->new( &HTTP::Status::RC_BAD_REQUEST,
 				  'You can not proxy with data');
     }
 
     my $method = $request->method;
     unless ($method eq 'GET' || $method eq 'HEAD') {
 	return HTTP::Response->new( &HTTP::Status::RC_BAD_REQUEST,
 				  'Library does not allow method ' .
 				  "$method for 'data:' URLs");
     }
 
     my $url = $request->uri;
     my $response = HTTP::Response->new( &HTTP::Status::RC_OK, "Document follows");
 
     my $media_type = $url->media_type;
 
     my $data = $url->data;
     $response->header('Content-Type'   => $media_type,
 		      'Content-Length' => length($data),
 		      'Date'           => time2str(time),
 		      'Server'         => "libwww-perl-internal/$LWP::VERSION"
 		     );
 
     $data = "" if $method eq "HEAD";
     return $self->collect_once($arg, $response, $data);
 }
 
 1;
### LWP/Protocol/file.pm ###
 package LWP::Protocol::file;
 
 require LWP::Protocol;
 @ISA = qw(LWP::Protocol);
 
 use strict;
 
 require LWP::MediaTypes;
 require HTTP::Request;
 require HTTP::Response;
 require HTTP::Status;
 require HTTP::Date;
 
 
 sub request
 {
     my($self, $request, $proxy, $arg, $size) = @_;
 
     $size = 4096 unless defined $size and $size > 0;
 
     if (defined $proxy)
     {
 	return HTTP::Response->new( &HTTP::Status::RC_BAD_REQUEST,
 				  'You can not proxy through the filesystem');
     }
 
     my $method = $request->method;
     unless ($method eq 'GET' || $method eq 'HEAD') {
 	return HTTP::Response->new( &HTTP::Status::RC_BAD_REQUEST,
 				  'Library does not allow method ' .
 				  "$method for 'file:' URLs");
     }
 
     my $url = $request->uri;
 
     my $scheme = $url->scheme;
     if ($scheme ne 'file') {
 	return HTTP::Response->new( &HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 			   "LWP::Protocol::file::request called for '$scheme'");
     }
 
     my $path  = $url->file;
 
     unless (-e $path) {
 	return HTTP::Response->new( &HTTP::Status::RC_NOT_FOUND,
 				  "File `$path' does not exist");
     }
     unless (-r _) {
 	return HTTP::Response->new( &HTTP::Status::RC_FORBIDDEN,
 				  'User does not have read permission');
     }
 
     my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$filesize,
        $atime,$mtime,$ctime,$blksize,$blocks)
 	    = stat(_);
 
 
     my $ims = $request->header('If-Modified-Since');
     if (defined $ims) {
 	my $time = HTTP::Date::str2time($ims);
 	if (defined $time and $time >= $mtime) {
 	    return HTTP::Response->new( &HTTP::Status::RC_NOT_MODIFIED,
 				      "$method $path");
 	}
     }
 
     my $response = HTTP::Response->new( &HTTP::Status::RC_OK );
 
     $response->header('Last-Modified', HTTP::Date::time2str($mtime));
 
     if (-d _) {         
 	opendir(D, $path) or
 	   return HTTP::Response->new( &HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 				     "Cannot read directory '$path': $!");
 	my(@files) = sort readdir(D);
 	closedir(D);
 
 	require URI::Escape;
 	require HTML::Entities;
         my $pathe = $path . ( $^O eq 'MacOS' ? ':' : '/');
 	for (@files) {
 	    my $furl = URI::Escape::uri_escape($_);
             if ( -d "$pathe$_" ) {
                 $furl .= '/';
                 $_ .= '/';
             }
 	    my $desc = HTML::Entities::encode($_);
 	    $_ = qq{<LI><A HREF="$furl">$desc</A>};
 	}
 	my $base = $url->clone;
 	unless ($base->path =~ m|/$|) {
 	    $base->path($base->path . "/");
 	}
 	my $html = join("\n",
 			"<HTML>\n<HEAD>",
 			"<TITLE>Directory $path</TITLE>",
 			"<BASE HREF=\"$base\">",
 			"</HEAD>\n<BODY>",
 			"<H1>Directory listing of $path</H1>",
 			"<UL>", @files, "</UL>",
 			"</BODY>\n</HTML>\n");
 
 	$response->header('Content-Type',   'text/html');
 	$response->header('Content-Length', length $html);
 	$html = "" if $method eq "HEAD";
 
 	return $self->collect_once($arg, $response, $html);
 
     }
 
     $response->header('Content-Length', $filesize);
     LWP::MediaTypes::guess_media_type($path, $response);
 
     if ($method ne "HEAD") {
 	open(F, $path) or return new
 	    HTTP::Response(&HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 			   "Cannot read file '$path': $!");
 	binmode(F);
 	$response =  $self->collect($arg, $response, sub {
 	    my $content = "";
 	    my $bytes = sysread(F, $content, $size);
 	    return \$content if $bytes > 0;
 	    return \ "";
 	});
 	close(F);
     }
 
     $response;
 }
 
 1;
### LWP/Protocol/ftp.pm ###
 package LWP::Protocol::ftp;
 
 
 use Carp ();
 
 use HTTP::Status ();
 use HTTP::Negotiate ();
 use HTTP::Response ();
 use LWP::MediaTypes ();
 use File::Listing ();
 
 require LWP::Protocol;
 @ISA = qw(LWP::Protocol);
 
 use strict;
 eval {
     package LWP::Protocol::MyFTP;
 
     require Net::FTP;
     Net::FTP->require_version(2.00);
 
     use vars qw(@ISA);
     @ISA=qw(Net::FTP);
 
     sub new {
 	my $class = shift;
 
 	my $self = $class->SUPER::new(@_) || return undef;
 
 	my $mess = $self->message;  
 	$mess =~ s|\n.*||s; 
 	$mess =~ s|\s*ready\.?$||;
 	$mess =~ s|\s*\(Version\s*|/| and $mess =~ s|\)$||;
 	${*$self}{myftp_server} = $mess;
 
 	$self;
     }
 
     sub http_server {
 	my $self = shift;
 	${*$self}{myftp_server};
     }
 
     sub home {
 	my $self = shift;
 	my $old = ${*$self}{myftp_home};
 	if (@_) {
 	    ${*$self}{myftp_home} = shift;
 	}
 	$old;
     }
 
     sub go_home {
 	my $self = shift;
 	$self->cwd(${*$self}{myftp_home});
     }
 
     sub request_count {
 	my $self = shift;
 	++${*$self}{myftp_reqcount};
     }
 
     sub ping {
 	my $self = shift;
 	return $self->go_home;
     }
 
 };
 my $init_failed = $@;
 
 
 sub _connect {
     my($self, $host, $port, $user, $account, $password, $timeout) = @_;
 
     my $key;
     my $conn_cache = $self->{ua}{conn_cache};
     if ($conn_cache) {
 	$key = "$host:$port:$user";
 	$key .= ":$account" if defined($account);
 	if (my $ftp = $conn_cache->withdraw("ftp", $key)) {
 	    if ($ftp->ping) {
 		$conn_cache->deposit("ftp", $key, $ftp);
 		return $ftp;
 	    }
 	}
     }
 
     my $ftp = LWP::Protocol::MyFTP->new($host,
 					Port => $port,
 					Timeout => $timeout,
 					LocalAddr => $self->{ua}{local_address},
 				       );
     unless ($ftp) {
 	$@ =~ s/^Net::FTP: //;
 	return HTTP::Response->new(&HTTP::Status::RC_INTERNAL_SERVER_ERROR, $@);
     }
 
     unless ($ftp->login($user, $password, $account)) {
 	my $mess = scalar($ftp->message);
 	$mess =~ s/\n$//;
 	my $res =  HTTP::Response->new(&HTTP::Status::RC_UNAUTHORIZED, $mess);
 	$res->header("Server", $ftp->http_server);
 	$res->header("WWW-Authenticate", qq(Basic Realm="FTP login"));
 	return $res;
     }
 
     my $home = $ftp->pwd;
     $ftp->home($home);
 
     $conn_cache->deposit("ftp", $key, $ftp) if $conn_cache;
 
     return $ftp;
 }
 
 
 sub request
 {
     my($self, $request, $proxy, $arg, $size, $timeout) = @_;
 
     $size = 4096 unless $size;
 
     if (defined $proxy)
     {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				   'You can not proxy through the ftp');
     }
 
     my $url = $request->uri;
     if ($url->scheme ne 'ftp') {
 	my $scheme = $url->scheme;
 	return HTTP::Response->new(&HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 		       "LWP::Protocol::ftp::request called for '$scheme'");
     }
 
     my $method = $request->method;
 
     unless ($method eq 'GET' || $method eq 'HEAD' || $method eq 'PUT') {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				   'Library does not allow method ' .
 				   "$method for 'ftp:' URLs");
     }
 
     if ($init_failed) {
 	return HTTP::Response->new(&HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 				   $init_failed);
     }
 
     my $host     = $url->host;
     my $port     = $url->port;
     my $user     = $url->user;
     my $password = $url->password;
 
     {
 	my($u,$p) = $request->authorization_basic;
 	if (defined $u) {
 	    $user = $u;
 	    $password = $p;
 	}
     }
 
     my $account = $request->header('Account');
 
     my $ftp = $self->_connect($host, $port, $user, $account, $password, $timeout);
     return $ftp if ref($ftp) eq "HTTP::Response"; 
 
     my $response = HTTP::Response->new(&HTTP::Status::RC_OK, "OK");
     $response->header(Server => $ftp->http_server);
     $response->header('Client-Request-Num' => $ftp->request_count);
     $response->request($request);
 
     my @path =  grep { length } $url->path_segments;
     my $remote_file = pop(@path);
     $remote_file = '' unless defined $remote_file;
 
     my $type;
     if (ref $remote_file) {
 	my @params;
 	($remote_file, @params) = @$remote_file;
 	for (@params) {
 	    $type = $_ if s/^type=//;
 	}
     }
 
     if ($type && $type eq 'a') {
 	$ftp->ascii;
     }
     else {
 	$ftp->binary;
     }
 
     for (@path) {
 	unless ($ftp->cwd($_)) {
 	    return HTTP::Response->new(&HTTP::Status::RC_NOT_FOUND,
 				       "Can't chdir to $_");
 	}
     }
 
     if ($method eq 'GET' || $method eq 'HEAD') {
 	if (my $mod_time = $ftp->mdtm($remote_file)) {
 	    $response->last_modified($mod_time);
 	    if (my $ims = $request->if_modified_since) {
 		if ($mod_time <= $ims) {
 		    $response->code(&HTTP::Status::RC_NOT_MODIFIED);
 		    $response->message("Not modified");
 		    return $response;
 		}
 	    }
 	}
 
 	my $max_size = undef;
 
 	if ($request->header('Range') && $ftp->supported('REST'))
 	{
 		my $range_info = $request->header('Range');
 
 		my ($start_byte,$end_byte) = $range_info =~ /.*=\s*(\d+)-(\d+)?/;
 		if ( defined $start_byte && !defined $end_byte ) {
 
 
 		  $ftp->restart( $start_byte );
 		}
 		elsif ( defined $start_byte && defined $end_byte &&
 			$start_byte >= 0 && $end_byte >= $start_byte ) {
 
 		  $ftp->restart( $start_byte );
 		  $max_size = $end_byte - $start_byte;
 		}
 		else {
 
 		  return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 		     'Incorrect syntax for Range request');
 		}
 	}
 	elsif ($request->header('Range') && !$ftp->supported('REST'))
 	{
 		return HTTP::Response->new(&HTTP::Status::RC_NOT_IMPLEMENTED,
 	         "Server does not support resume.");
 	}
 
 	my $data;  
 	if (length($remote_file) and $data = $ftp->retr($remote_file)) {
 	    my($type, @enc) = LWP::MediaTypes::guess_media_type($remote_file);
 	    $response->header('Content-Type',   $type) if $type;
 	    for (@enc) {
 		$response->push_header('Content-Encoding', $_);
 	    }
 	    my $mess = $ftp->message;
 	    if ($mess =~ /\((\d+)\s+bytes\)/) {
 		$response->header('Content-Length', "$1");
 	    }
 
 	    if ($method ne 'HEAD') {
 		$response = $self->collect($arg, $response, sub {
 		    my $content = '';
 		    my $result = $data->read($content, $size);
 
                     if (defined $max_size)
                     {
                       my $bytes_received = $data->bytes_read();
 
                       if ($bytes_received - length($content) > $max_size)
                       {
                         $content = '';
                       }
                       elsif ($bytes_received  > $max_size)
                       {
                         $content = substr($content, 0,
                           $max_size - ($bytes_received - length($content)) );
                       }
                       else
                       {
                       }
                     }
 
 		    return \$content;
 		} );
 	    }
 	    unless ($data->abort) {
 		if ($method ne 'HEAD' || $ftp->code != 0) {
 		    $response->code(&HTTP::Status::RC_INTERNAL_SERVER_ERROR);
 		    $response->message("FTP close response: " . $ftp->code .
 				       " " . $ftp->message);
 		}
 	    }
 	}
 	elsif (!length($remote_file) || ( $ftp->code >= 400 && $ftp->code < 600 )) {
 	    if (length($remote_file) && !$ftp->cwd($remote_file)) {
 		return HTTP::Response->new(&HTTP::Status::RC_NOT_FOUND,
 					   "File '$remote_file' not found");
 	    }
 
 	    my @lsl = $ftp->dir;
 
 	    my @variants =
 	      (
 	       ['html',  0.60, 'text/html'            ],
 	       ['dir',   1.00, 'text/ftp-dir-listing' ]
 	      );
 	    my $prefer = HTTP::Negotiate::choose(\@variants, $request);
 
 	    my $content = '';
 
 	    if (!defined($prefer)) {
 		return HTTP::Response->new(&HTTP::Status::RC_NOT_ACCEPTABLE,
 			       "Neither HTML nor directory listing wanted");
 	    }
 	    elsif ($prefer eq 'html') {
 		$response->header('Content-Type' => 'text/html');
 		$content = "<HEAD><TITLE>File Listing</TITLE>\n";
 		my $base = $request->uri->clone;
 		my $path = $base->path;
 		$base->path("$path/") unless $path =~ m|/$|;
 		$content .= qq(<BASE HREF="$base">\n</HEAD>\n);
 		$content .= "<BODY>\n<UL>\n";
 		for (File::Listing::parse_dir(\@lsl, 'GMT')) {
 		    my($name, $type, $size, $mtime, $mode) = @$_;
 		    $content .= qq(  <LI> <a href="$name">$name</a>);
 		    $content .= " $size bytes" if $type eq 'f';
 		    $content .= "\n";
 		}
 		$content .= "</UL></body>\n";
 	    }
 	    else {
 		$response->header('Content-Type', 'text/ftp-dir-listing');
 		$content = join("\n", @lsl, '');
 	    }
 
 	    $response->header('Content-Length', length($content));
 
 	    if ($method ne 'HEAD') {
 		$response = $self->collect_once($arg, $response, $content);
 	    }
 	}
 	else {
 	    my $res = HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 			  "FTP return code " . $ftp->code);
 	    $res->content_type("text/plain");
 	    $res->content($ftp->message);
 	    return $res;
 	}
     }
     elsif ($method eq 'PUT') {
 	unless (length($remote_file)) {
 	    return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				       "Must have a file name to PUT to");
 	}
 	my $data;
 	if ($data = $ftp->stor($remote_file)) {
 	    my $content = $request->content;
 	    my $bytes = 0;
 	    if (defined $content) {
 		if (ref($content) eq 'SCALAR') {
 		    $bytes = $data->write($$content, length($$content));
 		}
 		elsif (ref($content) eq 'CODE') {
 		    my($buf, $n);
 		    while (length($buf = &$content)) {
 			$n = $data->write($buf, length($buf));
 			last unless $n;
 			$bytes += $n;
 		    }
 		}
 		elsif (!ref($content)) {
 		    if (defined $content && length($content)) {
 			$bytes = $data->write($content, length($content));
 		    }
 		}
 		else {
 		    die "Bad content";
 		}
 	    }
 	    $data->close;
 
 	    $response->code(&HTTP::Status::RC_CREATED);
 	    $response->header('Content-Type', 'text/plain');
 	    $response->content("$bytes bytes stored as $remote_file on $host\n")
 
 	}
 	else {
 	    my $res = HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 					  "FTP return code " . $ftp->code);
 	    $res->content_type("text/plain");
 	    $res->content($ftp->message);
 	    return $res;
 	}
     }
     else {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				   "Illegal method $method");
     }
 
     $response;
 }
 
 1;
 
 __END__
 
 # This is what RFC 1738 has to say about FTP access:
 # --------------------------------------------------
 #
 # 3.2. FTP
 #
 #    The FTP URL scheme is used to designate files and directories on
 #    Internet hosts accessible using the FTP protocol (RFC959).
 #
 #    A FTP URL follow the syntax described in Section 3.1.  If :<port> is
 #    omitted, the port defaults to 21.
 #
 # 3.2.1. FTP Name and Password
 #
 #    A user name and password may be supplied; they are used in the ftp
 #    "USER" and "PASS" commands after first making the connection to the
 #    FTP server.  If no user name or password is supplied and one is
 #    requested by the FTP server, the conventions for "anonymous" FTP are
 #    to be used, as follows:
 #
 #         The user name "anonymous" is supplied.
 #
 #         The password is supplied as the Internet e-mail address
 #         of the end user accessing the resource.
 #
 #    If the URL supplies a user name but no password, and the remote
 #    server requests a password, the program interpreting the FTP URL
 #    should request one from the user.
 #
 # 3.2.2. FTP url-path
 #
 #    The url-path of a FTP URL has the following syntax:
 #
 #         <cwd1>/<cwd2>/.../<cwdN>/<name>;type=<typecode>
 #
 #    Where <cwd1> through <cwdN> and <name> are (possibly encoded) strings
 #    and <typecode> is one of the characters "a", "i", or "d".  The part
 #    ";type=<typecode>" may be omitted. The <cwdx> and <name> parts may be
 #    empty. The whole url-path may be omitted, including the "/"
 #    delimiting it from the prefix containing user, password, host, and
 #    port.
 #
 #    The url-path is interpreted as a series of FTP commands as follows:
 #
 #       Each of the <cwd> elements is to be supplied, sequentially, as the
 #       argument to a CWD (change working directory) command.
 #
 #       If the typecode is "d", perform a NLST (name list) command with
 #       <name> as the argument, and interpret the results as a file
 #       directory listing.
 #
 #       Otherwise, perform a TYPE command with <typecode> as the argument,
 #       and then access the file whose name is <name> (for example, using
 #       the RETR command.)
 #
 #    Within a name or CWD component, the characters "/" and ";" are
 #    reserved and must be encoded. The components are decoded prior to
 #    their use in the FTP protocol.  In particular, if the appropriate FTP
 #    sequence to access a particular file requires supplying a string
 #    containing a "/" as an argument to a CWD or RETR command, it is
 #    necessary to encode each "/".
 #
 #    For example, the URL <URL:ftp://myname@host.dom/%2Fetc/motd> is
 #    interpreted by FTP-ing to "host.dom", logging in as "myname"
 #    (prompting for a password if it is asked for), and then executing
 #    "CWD /etc" and then "RETR motd". This has a different meaning from
 #    <URL:ftp://myname@host.dom/etc/motd> which would "CWD etc" and then
 #    "RETR motd"; the initial "CWD" might be executed relative to the
 #    default directory for "myname". On the other hand,
 #    <URL:ftp://myname@host.dom//etc/motd>, would "CWD " with a null
 #    argument, then "CWD etc", and then "RETR motd".
 #
 #    FTP URLs may also be used for other operations; for example, it is
 #    possible to update a file on a remote file server, or infer
 #    information about it from the directory listings. The mechanism for
 #    doing so is not spelled out here.
 #
 # 3.2.3. FTP Typecode is Optional
 #
 #    The entire ;type=<typecode> part of a FTP URL is optional. If it is
 #    omitted, the client program interpreting the URL must guess the
 #    appropriate mode to use. In general, the data content type of a file
 #    can only be guessed from the name, e.g., from the suffix of the name;
 #    the appropriate type code to be used for transfer of the file can
 #    then be deduced from the data content of the file.
 #
 # 3.2.4 Hierarchy
 #
 #    For some file systems, the "/" used to denote the hierarchical
 #    structure of the URL corresponds to the delimiter used to construct a
 #    file name hierarchy, and thus, the filename will look similar to the
 #    URL path. This does NOT mean that the URL is a Unix filename.
 #
 # 3.2.5. Optimization
 #
 #    Clients accessing resources via FTP may employ additional heuristics
 #    to optimize the interaction. For some FTP servers, for example, it
 #    may be reasonable to keep the control connection open while accessing
 #    multiple URLs from the same server. However, there is no common
 #    hierarchical model to the FTP protocol, so if a directory change
 #    command has been given, it is impossible in general to deduce what
 #    sequence should be given to navigate to another directory for a
 #    second retrieval, if the paths are different.  The only reliable
 #    algorithm is to disconnect and reestablish the control connection.
### LWP/Protocol/gopher.pm ###
 package LWP::Protocol::gopher;
 
 
 use strict;
 use vars qw(@ISA);
 
 require HTTP::Response;
 require HTTP::Status;
 require IO::Socket;
 require IO::Select;
 
 require LWP::Protocol;
 @ISA = qw(LWP::Protocol);
 
 
 my %gopher2mimetype = (
     '0' => 'text/plain',                
     '1' => 'text/html',                 
     '4' => 'application/mac-binhex40',  
     '5' => 'application/zip',           
     '6' => 'application/octet-stream',  
     '7' => 'text/html',                 
     '9' => 'application/octet-stream',  
     'h' => 'text/html',                 
     'g' => 'image/gif',                 
     'I' => 'image/*',                   
 );
 
 my %gopher2encoding = (
     '6' => 'x_uuencode',                
 );
 
 sub request
 {
     my($self, $request, $proxy, $arg, $size, $timeout) = @_;
 
     $size = 4096 unless $size;
 
     if (defined $proxy) {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				   'You can not proxy through the gopher');
     }
 
     my $url = $request->uri;
     die "bad scheme" if $url->scheme ne 'gopher';
 
 
     my $method = $request->method;
     unless ($method eq 'GET' || $method eq 'HEAD') {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				   'Library does not allow method ' .
 				   "$method for 'gopher:' URLs");
     }
 
     my $gophertype = $url->gopher_type;
     unless (exists $gopher2mimetype{$gophertype}) {
 	return HTTP::Response->new(&HTTP::Status::RC_NOT_IMPLEMENTED,
 				   'Library does not support gophertype ' .
 				   $gophertype);
     }
 
     my $response = HTTP::Response->new(&HTTP::Status::RC_OK, "OK");
     $response->header('Content-type' => $gopher2mimetype{$gophertype}
 					|| 'text/plain');
     $response->header('Content-Encoding' => $gopher2encoding{$gophertype})
 	if exists $gopher2encoding{$gophertype};
 
     if ($method eq 'HEAD') {
 	$response->header('Client-Warning' => 'Client answer only');
 	return $response;
     }
     
     if ($gophertype eq '7' && ! $url->search) {
       return $self->collect_once($arg, $response, <<"EOT");
 <HEAD>
 <TITLE>Gopher Index</TITLE>
 <ISINDEX>
 </HEAD>
 <BODY>
 <H1>$url<BR>Gopher Search</H1>
 This is a searchable Gopher index.
 Use the search function of your browser to enter search terms.
 </BODY>
 EOT
     }
 
     my $host = $url->host;
     my $port = $url->port;
 
     my $requestLine = "";
 
     my $selector = $url->selector;
     if (defined $selector) {
 	$requestLine .= $selector;
 	my $search = $url->search;
 	if (defined $search) {
 	    $requestLine .= "\t$search";
 	    my $string = $url->string;
 	    if (defined $string) {
 		$requestLine .= "\t$string";
 	    }
 	}
     }
     $requestLine .= "\015\012";
 
 
     my $socket = IO::Socket::INET->new(PeerAddr => $host,
 				       PeerPort => $port,
 				       LocalAddr => $self->{ua}{local_address},
 				       Proto    => 'tcp',
 				       Timeout  => $timeout);
     die "Can't connect to $host:$port" unless $socket;
     my $sel = IO::Select->new($socket);
 
     {
 	die "write timeout" if $timeout && !$sel->can_write($timeout);
 	my $n = syswrite($socket, $requestLine, length($requestLine));
 	die $! unless defined($n);
 	die "short write" if $n != length($requestLine);
     }
 
     my $user_arg = $arg;
 
     $arg = undef if $gophertype eq '1' || $gophertype eq '7';
 
     my $buf = '';
     $response = $self->collect($arg, $response, sub {
 	die "read timeout" if $timeout && !$sel->can_read($timeout);
         my $n = sysread($socket, $buf, $size);
 	die $! unless defined($n);
 	return \$buf;
       } );
 
     if ($gophertype eq '1' || $gophertype eq '7') {
 	my $content = menu2html($response->content);
 	if (defined $user_arg) {
 	    $response = $self->collect_once($user_arg, $response, $content);
 	}
 	else {
 	    $response->content($content);
 	}
     }
 
     $response;
 }
 
 
 sub gopher2url
 {
     my($gophertype, $path, $host, $port) = @_;
 
     my $url;
 
     if ($gophertype eq '8' || $gophertype eq 'T') {
 	$url = $HTTP::URI_CLASS->new($gophertype eq '8' ? 'telnet:':'tn3270:');
 	$url->user($path) if defined $path;
     }
     else {
 	$path = URI::Escape::uri_escape($path);
 	$url = $HTTP::URI_CLASS->new("gopher:/$gophertype$path");
     }
     $url->host($host);
     $url->port($port);
     $url;
 }
 
 sub menu2html {
     my($menu) = @_;
 
     $menu =~ s/\015//g;  
     my $tmp = <<"EOT";
 <HTML>
 <HEAD>
    <TITLE>Gopher menu</TITLE>
 </HEAD>
 <BODY>
 <H1>Gopher menu</H1>
 EOT
     for (split("\n", $menu)) {
 	last if /^\./;
 	my($pretty, $path, $host, $port) = split("\t");
 
 	$pretty =~ s/^(.)//;
 	my $type = $1;
 
 	my $url = gopher2url($type, $path, $host, $port)->as_string;
 	$tmp .= qq{<A HREF="$url">$pretty</A><BR>\n};
     }
     $tmp .= "</BODY>\n</HTML>\n";
     $tmp;
 }
 
 1;
### LWP/Protocol/http.pm ###
 package LWP::Protocol::http;
 
 use strict;
 
 require HTTP::Response;
 require HTTP::Status;
 require Net::HTTP;
 
 use vars qw(@ISA @EXTRA_SOCK_OPTS);
 
 require LWP::Protocol;
 @ISA = qw(LWP::Protocol);
 
 my $CRLF = "\015\012";
 
 sub _new_socket
 {
     my($self, $host, $port, $timeout) = @_;
 
     if ( ($host =~ /:/) && ($host !~ /^\[/) ) {
       $host = "[$host]";
     }
 
     local($^W) = 0;  
     my $sock = $self->socket_class->new(PeerAddr => $host,
 					PeerPort => $port,
 					LocalAddr => $self->{ua}{local_address},
 					Proto    => 'tcp',
 					Timeout  => $timeout,
 					KeepAlive => !!$self->{ua}{conn_cache},
 					SendTE    => 1,
 					$self->_extra_sock_opts($host, $port),
 				       );
 
     unless ($sock) {
 	my $status = "Can't connect to $host:$port";
 	if ($@ =~ /\bconnect: (.*)/ ||
 	    $@ =~ /\b(Bad hostname)\b/ ||
 	    $@ =~ /\b(certificate verify failed)\b/ ||
 	    $@ =~ /\b(Crypt-SSLeay can't verify hostnames)\b/
 	) {
 	    $status .= " ($1)";
 	}
 	die "$status\n\n$@";
     }
 
     eval { $sock->blocking(0); };
 
     $sock;
 }
 
 sub socket_type
 {
     return "http";
 }
 
 sub socket_class
 {
     my $self = shift;
     (ref($self) || $self) . "::Socket";
 }
 
 sub _extra_sock_opts  
 {
     return @EXTRA_SOCK_OPTS;
 }
 
 sub _check_sock
 {
 }
 
 sub _get_sock_info
 {
     my($self, $res, $sock) = @_;
     if (defined(my $peerhost = $sock->peerhost)) {
         $res->header("Client-Peer" => "$peerhost:" . $sock->peerport);
     }
 }
 
 sub _fixup_header
 {
     my($self, $h, $url, $proxy) = @_;
 
     my $hhost = $url->authority;
     if ($hhost =~ s/^([^\@]*)\@//) {  
 	if (defined($1) && not $h->header('Authorization')) {
 	    require URI::Escape;
 	    $h->authorization_basic(map URI::Escape::uri_unescape($_),
 				    split(":", $1, 2));
 	}
     }
     $h->init_header('Host' => $hhost);
 
     if ($proxy && $url->scheme ne 'https') {
 	my $p_auth = $proxy->userinfo();
 	if(defined $p_auth) {
 	    require URI::Escape;
 	    $h->proxy_authorization_basic(map URI::Escape::uri_unescape($_),
 					  split(":", $p_auth, 2))
 	}
     }
 }
 
 sub hlist_remove {
     my($hlist, $k) = @_;
     $k = lc $k;
     for (my $i = @$hlist - 2; $i >= 0; $i -= 2) {
 	next unless lc($hlist->[$i]) eq $k;
 	splice(@$hlist, $i, 2);
     }
 }
 
 sub request
 {
     my($self, $request, $proxy, $arg, $size, $timeout) = @_;
 
     $size ||= 4096;
 
     my $method = $request->method;
     unless ($method =~ /^[A-Za-z0-9_!\#\$%&\'*+\-.^\`|~]+$/) {  
 	return HTTP::Response->new( &HTTP::Status::RC_BAD_REQUEST,
 				  'Library does not allow method ' .
 				  "$method for 'http:' URLs");
     }
 
     my $url = $request->uri;
 
 
     my $ssl_tunnel = $proxy && $url->scheme eq 'https'
 	&& $url->host.":".$url->port;
 
     my ($host,$port) = $proxy
 	? ($proxy->host,$proxy->port)
 	: ($url->host,$url->port);
     my $fullpath =
 	$method eq 'CONNECT' ? $url->host . ":" . $url->port :
 	$proxy && ! $ssl_tunnel ? $url->as_string :
 	do {
 	    my $path = $url->path_query;
 	    $path = "/$path" if $path !~m{^/};
 	    $path
 	};
 
     my $socket;
     my $conn_cache = $self->{ua}{conn_cache};
     my $cache_key;
     if ( $conn_cache ) {
 	$cache_key = "$host:$port";
 	$cache_key .= "!".$ssl_tunnel if $ssl_tunnel;
 	if ( $socket = $conn_cache->withdraw($self->socket_type,$cache_key)) {
 	    if ($socket->can_read(0)) {
 		$socket->close;
 		$socket = undef;
 	    } 
 	}
     }
 
     if ( ! $socket && $ssl_tunnel ) {
 	my $proto_https = LWP::Protocol::create('https',$self->{ua})
 	    or die "no support for scheme https found";
 
 	if ( my $upgrade_sub = $proto_https->can('_upgrade_sock')) {
 	    my $response = $self->request(
 		HTTP::Request->new('CONNECT',"http://$ssl_tunnel"),
 		$proxy,
 		undef,$size,$timeout
 	    );
 	    $response->is_success or die
 		"establishing SSL tunnel failed: ".$response->status_line;
 	    $socket = $upgrade_sub->($proto_https,
 		$response->{client_socket},$url)
 		or die "SSL upgrade failed: $@";
 	} else {
 	    $socket = $proto_https->_new_socket($url->host,$url->port,$timeout);
 	}
     }
 
     if ( ! $socket ) {
 	$socket = $self->_new_socket($host, $port, $timeout );
     }
 
     my $http_version = "";
     if (my $proto = $request->protocol) {
 	if ($proto =~ /^(?:HTTP\/)?(1.\d+)$/) {
 	    $http_version = $1;
 	    $socket->http_version($http_version);
 	    $socket->send_te(0) if $http_version eq "1.0";
 	}
     }
 
     $self->_check_sock($request, $socket);
 
     my @h;
     my $request_headers = $request->headers->clone;
     $self->_fixup_header($request_headers, $url, $proxy);
 
     $request_headers->scan(sub {
 			       my($k, $v) = @_;
 			       $k =~ s/^://;
 			       $v =~ s/\n/ /g;
 			       push(@h, $k, $v);
 			   });
 
     my $content_ref = $request->content_ref;
     $content_ref = $$content_ref if ref($$content_ref);
     my $chunked;
     my $has_content;
 
     if (ref($content_ref) eq 'CODE') {
 	my $clen = $request_headers->header('Content-Length');
 	$has_content++ if $clen;
 	unless (defined $clen) {
 	    push(@h, "Transfer-Encoding" => "chunked");
 	    $has_content++;
 	    $chunked++;
 	}
     }
     else {
 	my $clen = $request_headers->header('Content-Length');
 	if (defined($$content_ref) && length($$content_ref)) {
 	    $has_content = length($$content_ref);
 	    if (!defined($clen) || $clen ne $has_content) {
 		if (defined $clen) {
 		    warn "Content-Length header value was wrong, fixed";
 		    hlist_remove(\@h, 'Content-Length');
 		}
 		push(@h, 'Content-Length' => $has_content);
 	    }
 	}
 	elsif ($clen) {
 	    warn "Content-Length set when there is no content, fixed";
 	    hlist_remove(\@h, 'Content-Length');
 	}
     }
 
     my $write_wait = 0;
     $write_wait = 2
 	if ($request_headers->header("Expect") || "") =~ /100-continue/;
 
     my $req_buf = $socket->format_request($method, $fullpath, @h);
 
     if (!$has_content || $write_wait || $has_content > 8*1024) {
       WRITE:
         {
             my $n = $socket->syswrite($req_buf, length($req_buf));
             unless (defined $n) {
                 redo WRITE if $!{EINTR};
                 if ($!{EWOULDBLOCK} || $!{EAGAIN}) {
                     select(undef, undef, undef, 0.1);
                     redo WRITE;
                 }
                 die "write failed: $!";
             }
             if ($n) {
                 substr($req_buf, 0, $n, "");
             }
             else {
                 select(undef, undef, undef, 0.5);
             }
             redo WRITE if length $req_buf;
         }
     }
 
     my($code, $mess, @junk);
     my $drop_connection;
 
     if ($has_content) {
 	my $eof;
 	my $wbuf;
 	my $woffset = 0;
       INITIAL_READ:
 	if ($write_wait) {
 	}
 	elsif (ref($content_ref) eq 'CODE') {
 	    my $buf = &$content_ref();
 	    $buf = "" unless defined($buf);
 	    $buf = sprintf "%x%s%s%s", length($buf), $CRLF, $buf, $CRLF
 		if $chunked;
 	    substr($buf, 0, 0) = $req_buf if $req_buf;
 	    $wbuf = \$buf;
 	}
 	else {
 	    if ($req_buf) {
 		my $buf = $req_buf . $$content_ref;
 		$wbuf = \$buf;
 	    }
 	    else {
 		$wbuf = $content_ref;
 	    }
 	    $eof = 1;
 	}
 
 	my $fbits = '';
 	vec($fbits, fileno($socket), 1) = 1;
 
       WRITE:
 	while ($write_wait || $woffset < length($$wbuf)) {
 
 	    my $sel_timeout = $timeout;
 	    if ($write_wait) {
 		$sel_timeout = $write_wait if $write_wait < $sel_timeout;
 	    }
 	    my $time_before;
             $time_before = time if $sel_timeout;
 
 	    my $rbits = $fbits;
 	    my $wbits = $write_wait ? undef : $fbits;
             my $sel_timeout_before = $sel_timeout;
           SELECT:
             {
                 my $nfound = select($rbits, $wbits, undef, $sel_timeout);
                 if ($nfound < 0) {
                     if ($!{EINTR} || $!{EWOULDBLOCK} || $!{EAGAIN}) {
                         if ($time_before) {
                             $sel_timeout = $sel_timeout_before - (time - $time_before);
                             $sel_timeout = 0 if $sel_timeout < 0;
                         }
                         redo SELECT;
                     }
                     die "select failed: $!";
                 }
 	    }
 
 	    if ($write_wait) {
 		$write_wait -= time - $time_before;
 		$write_wait = 0 if $write_wait < 0;
 	    }
 
 	    if (defined($rbits) && $rbits =~ /[^\0]/) {
 		my $buf = $socket->_rbuf;
 		my $n = $socket->sysread($buf, 1024, length($buf));
                 unless (defined $n) {
                     die "read failed: $!" unless  $!{EINTR} || $!{EWOULDBLOCK} || $!{EAGAIN};
                 }
 		elsif ($n == 0) {
                     $drop_connection++;
                     last WRITE;
 		}
 		$socket->_rbuf($buf);
 		if (!$code && $buf =~ /\015?\012\015?\012/) {
 		    ($code, $mess, @h) = $socket->read_response_headers(laxed => 1,
 									junk_out => \@junk,
 								       );
 		    if ($code eq "100") {
 			$write_wait = 0;
 			undef($code);
 			goto INITIAL_READ;
 		    }
 		    else {
 			$drop_connection++;
 			last WRITE;
 		    }
 		}
 	    }
 	    if (defined($wbits) && $wbits =~ /[^\0]/) {
 		my $n = $socket->syswrite($$wbuf, length($$wbuf), $woffset);
                 unless (defined $n) {
                     die "write failed: $!" unless $!{EINTR} || $!{EWOULDBLOCK} || $!{EAGAIN};
                     $n = 0;  
                 }
                 elsif ($n == 0) {
 		    die "write failed: no bytes written";
 		}
 		$woffset += $n;
 
 		if (!$eof && $woffset >= length($$wbuf)) {
 		    my $buf = &$content_ref();
 		    $buf = "" unless defined($buf);
 		    $eof++ unless length($buf);
 		    $buf = sprintf "%x%s%s%s", length($buf), $CRLF, $buf, $CRLF
 			if $chunked;
 		    $wbuf = \$buf;
 		    $woffset = 0;
 		}
 	    }
 	} 
     }
 
     ($code, $mess, @h) = $socket->read_response_headers(laxed => 1, junk_out => \@junk)
 	unless $code;
     ($code, $mess, @h) = $socket->read_response_headers(laxed => 1, junk_out => \@junk)
 	if $code eq "100";
 
     my $response = HTTP::Response->new($code, $mess);
     my $peer_http_version = $socket->peer_http_version;
     $response->protocol("HTTP/$peer_http_version");
     {
 	local $HTTP::Headers::TRANSLATE_UNDERSCORE;
 	$response->push_header(@h);
     }
     $response->push_header("Client-Junk" => \@junk) if @junk;
 
     $response->request($request);
     $self->_get_sock_info($response, $socket);
 
     if ($method eq "CONNECT") {
 	$response->{client_socket} = $socket;  
 	return $response;
     }
 
     if (my @te = $response->remove_header('Transfer-Encoding')) {
 	$response->push_header('Client-Transfer-Encoding', \@te);
     }
     $response->push_header('Client-Response-Num', scalar $socket->increment_response_count);
 
     my $complete;
     $response = $self->collect($arg, $response, sub {
 	my $buf = ""; 
 	my $n;
       READ:
 	{
 	    $n = $socket->read_entity_body($buf, $size);
             unless (defined $n) {
                 redo READ if $!{EINTR} || $!{EWOULDBLOCK} || $!{EAGAIN} || $!{ENOTTY};
                 die "read failed: $!";
             }
 	    redo READ if $n == -1;
 	}
 	$complete++ if !$n;
         return \$buf;
     } );
     $drop_connection++ unless $complete;
 
     @h = $socket->get_trailers;
     if (@h) {
 	local $HTTP::Headers::TRANSLATE_UNDERSCORE;
 	$response->push_header(@h);
     }
 
     unless ($drop_connection) {
 	if ($cache_key) {
 	    my %connection = map { (lc($_) => 1) }
 		             split(/\s*,\s*/, ($response->header("Connection") || ""));
 	    if (($peer_http_version eq "1.1" && !$connection{close}) ||
 		$connection{"keep-alive"})
 	    {
 		$conn_cache->deposit($self->socket_type, $cache_key, $socket);
 	    }
 	}
     }
 
     $response;
 }
 
 
 package LWP::Protocol::http::SocketMethods;
 
 sub ping {
     my $self = shift;
     !$self->can_read(0);
 }
 
 sub increment_response_count {
     my $self = shift;
     return ++${*$self}{'myhttp_response_count'};
 }
 
 package LWP::Protocol::http::Socket;
 use vars qw(@ISA);
 @ISA = qw(LWP::Protocol::http::SocketMethods Net::HTTP);
 
 1;
### LWP/Protocol/http/SocketUnixAlt.pm ###
 package LWP::Protocol::http::SocketUnixAlt;
 
 use 5.010001;
 use strict;
 use warnings;
 use vars qw( @ISA $VERSION );
 use IO::Socket;
 use LWP::Protocol::http;
 
 @ISA = qw( LWP::Protocol::http );
 
 our $VERSION = '0.0204'; 
 
 sub _new_socket {
 	my ($self, $path, $timeout) = @_;
 
 	local($^W) = 0;
 	my $sock = $self->socket_class->new(
 			Peer	=> $path,
 			Type	=> SOCK_STREAM,
 			Timeout	=> $timeout,
 			Host    => 'localhost',
 	);
 
 	unless($sock) {
 		$@ =~ s/^.*?: //;
 		die "Can't open socket $path\: $@";
 	}
 
 	eval { $sock->blocking(0); };
 
 	$sock;
 }
 
 sub request {
     my($self, $request, undef, $arg, $size, $timeout) = @_;
 
     $size ||= 4096;
 
     my $method = $request->method;
     unless ($method =~ /^[A-Za-z0-9_!\#\$%&\'*+\-.^\`|~]+$/) {  
 		return new HTTP::Response &HTTP::Status::RC_BAD_REQUEST,
 				  'Library does not allow method ' .
 				  "$method for 'http:' URLs";
     }
 
     my $url = $request->url;
 	my $path = $url->path_query;
 	my $fullpath;
 	if ($path =~ s!/(/.+)!!) {
 		$fullpath = $1;
 	} else {
 		$fullpath = "/";
 	}
 
     my $socket = $self->_new_socket($path, $timeout);
     $self->_check_sock($request, $socket);
 
     my @h;
     my $request_headers = $request->headers->clone;
     $self->_fixup_header($request_headers, $url);
 
     $request_headers->scan(sub {
 			       my($k, $v) = @_;
 			       $v =~ s/\n/ /g;
 			       push(@h, $k, $v);
 			   });
 
     my $content_ref = $request->content_ref;
     $content_ref = $$content_ref if ref($$content_ref);
     my $chunked;
     my $has_content;
 
     if (ref($content_ref) eq 'CODE') {
 		my $clen = $request_headers->header('Content-Length');
 		$has_content++ if $clen;
 		unless (defined $clen) {
 			push(@h, "Transfer-Encoding" => "chunked");
 			$has_content++;
 			$chunked++;
 		}
     } else {
 		my $clen = $request_headers->header('Content-Length');
 		if (defined($$content_ref) && length($$content_ref)) {
 			$has_content++;
 			if (!defined($clen) || $clen ne length($$content_ref)) {
 				if (defined $clen) {
 					warn "Content-Length header value was wrong, fixed";
 					hlist_remove(\@h, 'Content-Length');
 				}
 				push(@h, 'Content-Length' => length($$content_ref));
 			}
 		} elsif ($clen) {
 			warn "Content-Length set when there is not content, fixed";
 			hlist_remove(\@h, 'Content-Length');
 		}
     }
 
     my $req_buf = $socket->format_request($method, $fullpath, @h);
 
     {
 		my $n = $socket->syswrite($req_buf, length($req_buf));
 		die $! unless defined($n);
 		die "short write" unless $n == length($req_buf);
     }
 
     my($code, $mess, @junk);
 
     if ($has_content) {
 		my $write_wait = 0;
 		$write_wait = 2
 			if ($request_headers->header("Expect") || "") =~ /100-continue/;
 
 		my $eof;
 		my $wbuf;
 		my $woffset = 0;
 		if (ref($content_ref) eq 'CODE') {
 			my $buf = &$content_ref();
 			$buf = "" unless defined($buf);
 			$buf = sprintf "%x%s%s%s", length($buf), $LWP::Protocol::http::CRLF,
 				$buf, $LWP::Protocol::http::CRLF if $chunked;
 			$wbuf = \$buf;
 		} else {
 			$wbuf = $content_ref;
 			$eof = 1;
 		}
 
 		my $fbits = '';
 		vec($fbits, fileno($socket), 1) = 1;
 
 		while ($woffset < length($$wbuf)) {
 
 			my $time_before;
 			my $sel_timeout = $timeout;
 			if ($write_wait) {
 				$time_before = time;
 				$sel_timeout = $write_wait if $write_wait < $sel_timeout;
 			}
 
 			my $rbits = $fbits;
 			my $wbits = $write_wait ? undef : $fbits;
 			my $nfound = select($rbits, $wbits, undef, $sel_timeout);
 			unless (defined $nfound) {
 				die "select failed: $!";
 			}
 
 			if ($write_wait) {
 				$write_wait -= time - $time_before;
 				$write_wait = 0 if $write_wait < 0;
 			}
 
 			if (defined($rbits) && $rbits =~ /[^\0]/) {
 				my $buf = $socket->_rbuf;
 				my $n = $socket->sysread($buf, 1024, length($buf));
 				unless ($n) {
 					die "EOF";
 				}
 				$socket->_rbuf($buf);
 				if ($buf =~ /\015?\012\015?\012/) {
 					($code, $mess, @h) = $socket->read_response_headers(laxed => 1,
 											junk_out => \@junk,
 											   );
 					if ($code eq "100") {
 						$write_wait = 0;
 						undef($code);
 					} else {
 						last;
 					}
 				}
 			}
 			if (defined($wbits) && $wbits =~ /[^\0]/) {
 				my $n = $socket->syswrite($$wbuf, length($$wbuf), $woffset);
 				unless ($n) {
 					die "syswrite: $!" unless defined $n;
 					die "syswrite: no bytes written";
 				}
 				$woffset += $n;
 
 				if (!$eof && $woffset >= length($$wbuf)) {
 					my $buf = &$content_ref();
 					$buf = "" unless defined($buf);
 					$eof++ unless length($buf);
 					$buf = sprintf "%x%s%s%s", length($buf), $LWP::Protocol::http::CRLF,
 						$buf, $LWP::Protocol::http::CRLF if $chunked;
 					$wbuf = \$buf;
 					$woffset = 0;
 				}
 			}
 		}
     }
 
     ($code, $mess, @h) = $socket->read_response_headers(laxed => 1, junk_out => \@junk)
 	unless $code;
     ($code, $mess, @h) = $socket->read_response_headers(laxed => 1, junk_out => \@junk)
 	if $code eq "100";
 
     my $response = HTTP::Response->new($code, $mess);
     my $peer_http_version = $socket->peer_http_version;
     $response->protocol("HTTP/$peer_http_version");
     while (@h) {
 		my($k, $v) = splice(@h, 0, 2);
 		$response->push_header($k, $v);
     }
     $response->push_header("Client-Junk" => \@junk) if @junk;
 
     $response->request($request);
     $self->_get_sock_info($response, $socket);
 
     if ($method eq "CONNECT") {
 		$response->{client_socket} = $socket;  
 		return $response;
     }
 
     if (my @te = $response->remove_header('Transfer-Encoding')) {
 		$response->push_header('Client-Transfer-Encoding', \@te);
     }
     $response->push_header('Client-Response-Num', $socket->increment_response_count);
 
     my $complete;
     $response = $self->collect($arg, $response, sub {
 		my $buf = ""; 
 		my $n;
 		READ:
 		{
 			$n = $socket->read_entity_body($buf, $size);
 			die "Can't read entity body: $!" unless defined $n;
 			redo READ if $n == -1;
 		}
 		$complete++ if !$n;
 			return \$buf;
     } );
 
     @h = $socket->get_trailers;
     while (@h) {
 		my($k, $v) = splice(@h, 0, 2);
 		$response->push_header($k, $v);
     }
 
     $response;
 }
 
 package LWP::Protocol::http::SocketUnixAlt::Socket;
 
 use strict;
 use warnings;
 use vars qw( @ISA );
 
 @ISA =qw(	LWP::Protocol::http::SocketMethods
 			Net::HTTP::Methods
 			IO::Socket::UNIX
 		);
 
 sub configure {
 	my ($self, $cnf) = @_;
 	$self->http_configure($cnf);
 }
 
 sub http_connect {
 	my ($self, $cnf) = @_;
 	$self->SUPER::configure($cnf);
 }
 
 sub peerport { }
 sub peerhost { }
 
 1;
 
 __END__
 
### LWP/Protocol/loopback.pm ###
 package LWP::Protocol::loopback;
 
 use strict;
 use vars qw(@ISA);
 require HTTP::Response;
 
 require LWP::Protocol;
 @ISA = qw(LWP::Protocol);
 
 sub request {
     my($self, $request, $proxy, $arg, $size, $timeout) = @_;
 
     my $response = HTTP::Response->new(200, "OK");
     $response->content_type("message/http; msgtype=request");
 
     $response->header("Via", "loopback/1.0 $proxy")
 	if $proxy;
 
     $response->header("X-Arg", $arg);
     $response->header("X-Read-Size", $size);
     $response->header("X-Timeout", $timeout);
 
     return $self->collect_once($arg, $response, $request->as_string);
 }
 
 1;
### LWP/Protocol/mailto.pm ###
 package LWP::Protocol::mailto;
 
 
 require LWP::Protocol;
 require HTTP::Request;
 require HTTP::Response;
 require HTTP::Status;
 
 use Carp;
 use strict;
 use vars qw(@ISA $SENDMAIL);
 
 @ISA = qw(LWP::Protocol);
 
 unless ($SENDMAIL = $ENV{SENDMAIL}) {
     for my $sm (qw(/usr/sbin/sendmail
 		   /usr/lib/sendmail
 		   /usr/ucblib/sendmail
 		  ))
     {
 	if (-x $sm) {
 	    $SENDMAIL = $sm;
 	    last;
 	}
     }
     die "Can't find the 'sendmail' program" unless $SENDMAIL;
 }
 
 sub request
 {
     my($self, $request, $proxy, $arg, $size) = @_;
 
     my ($mail, $addr) if $^O eq "MacOS";
     my @text = () if $^O eq "MacOS";
 
     if (defined $proxy)
     {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				  'You can not proxy with mail');
     }
 
     my $method = $request->method;
 
     if ($method ne 'POST') {
 	return HTTP::Response->new( &HTTP::Status::RC_BAD_REQUEST,
 				  'Library does not allow method ' .
 				  "$method for 'mailto:' URLs");
     }
 
     my $url = $request->uri;
 
     my $scheme = $url->scheme;
     if ($scheme ne 'mailto') {
 	return HTTP::Response->new( &HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 			 "LWP::Protocol::mailto::request called for '$scheme'");
     }
     if ($^O eq "MacOS") {
 	eval {
 	    require Mail::Internet;
 	};
 	if($@) {
 	    return HTTP::Response->new( &HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 	               "You don't have MailTools installed");
 	}
 	unless ($ENV{SMTPHOSTS}) {
 	    return HTTP::Response->new( &HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 	               "You don't have SMTPHOSTS defined");
 	}
     }
     else {
 	unless (-x $SENDMAIL) {
 	    return HTTP::Response->new( &HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 	               "You don't have $SENDMAIL");
     }
     }
     if ($^O eq "MacOS") {
 	    $mail = Mail::Internet->new or
 	    return HTTP::Response->new( &HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 	    "Can't get a Mail::Internet object");
     }
     else {
 	open(SENDMAIL, "| $SENDMAIL -oi -t") or
 	    return HTTP::Response->new( &HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 	               "Can't run $SENDMAIL: $!");
     }
     if ($^O eq "MacOS") {
 	$addr = $url->encoded822addr;
     }
     else {
 	$request = $request->clone;  
 	my @h = $url->headers;  
 	while (@h) {
 	    my $k = shift @h;
 	    my $v = shift @h;
 	    next unless defined $v;
 	    if (lc($k) eq "body") {
 		$request->content($v);
 	    }
 	    else {
 		$request->push_header($k => $v);
 	    }
 	}
     }
     if ($^O eq "MacOS") {
 	$mail->add(To => $addr);
 	$mail->add(split(/[:\n]/,$request->headers_as_string));
     }
     else {
 	print SENDMAIL $request->headers_as_string;
 	print SENDMAIL "\n";
     }
     my $content = $request->content;
     if (defined $content) {
 	my $contRef = ref($content) ? $content : \$content;
 	if (ref($contRef) eq 'SCALAR') {
 	    if ($^O eq "MacOS") {
 		@text = split("\n",$$contRef);
 		foreach (@text) {
 		    $_ .= "\n";
 		}
 	    }
 	    else {
 	    print SENDMAIL $$contRef;
 	    }
 
 	}
 	elsif (ref($contRef) eq 'CODE') {
 	    my $d;
 	    if ($^O eq "MacOS") {
 		my $stuff = "";
 		while (length($d = &$contRef)) {
 		    $stuff .= $d;
 		}
 		@text = split("\n",$stuff);
 		foreach (@text) {
 		    $_ .= "\n";
 		}
 	    }
 	    else {
 		print SENDMAIL $d;
 	    }
 	}
     }
     if ($^O eq "MacOS") {
 	$mail->body(\@text);
 	unless ($mail->smtpsend) {
 	    return HTTP::Response->new(&HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 				       "Mail::Internet->smtpsend unable to send message to <$addr>");
 	}
     }
     else {
 	unless (close(SENDMAIL)) {
 	    my $err = $! ? "$!" : "Exit status $?";
 	    return HTTP::Response->new(&HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 				       "$SENDMAIL: $err");
 	}
     }
 
 
     my $response = HTTP::Response->new(&HTTP::Status::RC_ACCEPTED,
 				       "Mail accepted");
     $response->header('Content-Type', 'text/plain');
     if ($^O eq "MacOS") {
 	$response->header('Server' => "Mail::Internet $Mail::Internet::VERSION");
 	$response->content("Message sent to <$addr>\n");
     }
     else {
 	$response->header('Server' => $SENDMAIL);
 	my $to = $request->header("To");
 	$response->content("Message sent to <$to>\n");
     }
 
     return $response;
 }
 
 1;
### LWP/Protocol/nntp.pm ###
 package LWP::Protocol::nntp;
 
 
 require LWP::Protocol;
 @ISA = qw(LWP::Protocol);
 
 require HTTP::Response;
 require HTTP::Status;
 require Net::NNTP;
 
 use strict;
 
 
 sub request
 {
     my($self, $request, $proxy, $arg, $size, $timeout) = @_;
 
     $size = 4096 unless $size;
 
     if (defined $proxy) {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				   'You can not proxy through NNTP');
     }
 
     my $url = $request->uri;
     my $scheme = $url->scheme;
     unless ($scheme eq 'news' || $scheme eq 'nntp') {
 	return HTTP::Response->new(&HTTP::Status::RC_INTERNAL_SERVER_ERROR,
 				   "LWP::Protocol::nntp::request called for '$scheme'");
     }
 
     my $method = $request->method;
     unless ($method eq 'GET' || $method eq 'HEAD' || $method eq 'POST') {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				   'Library does not allow method ' .
 				   "$method for '$scheme:' URLs");
     }
 
     my $groupart = $url->_group;
     my $is_art = $groupart =~ /@/;
 
     if ($is_art && $method eq 'POST') {
 	return HTTP::Response->new(&HTTP::Status::RC_BAD_REQUEST,
 				   "Can't post to an article <$groupart>");
     }
 
     my $nntp = Net::NNTP->new($url->host,
 			      Timeout => $timeout,
 			     );
     die "Can't connect to nntp server" unless $nntp;
 
     if ($nntp->status != 2) {
 	return HTTP::Response->new(&HTTP::Status::RC_SERVICE_UNAVAILABLE,
 				   $nntp->message);
     }
     my $response = HTTP::Response->new(&HTTP::Status::RC_OK, "OK");
 
     my $mess = $nntp->message;
 
     $mess =~ s/\s+ready\b.*//;
     $mess =~ s/^\S+\s+//;
     $response->header(Server => $mess);
 
     if ($method eq 'POST') {
 	$nntp->quit; $nntp = undef;
 	$response->code(&HTTP::Status::RC_NOT_IMPLEMENTED);
 	$response->message("POST not implemented yet");
 	return $response;
     }
 
     if (!$is_art) {
 	if (!$nntp->group($groupart)) {
 	    $response->code(&HTTP::Status::RC_NOT_FOUND);
 	    $response->message($nntp->message);
 	}
 	$nntp->quit; $nntp = undef;
 	if ($method eq 'GET' && $response->is_success) {
 	    $response->code(&HTTP::Status::RC_NOT_IMPLEMENTED);
 	    $response->message("GET newsgroup not implemented yet");
 	}
 	return $response;
     }
 
     my $get = $method eq 'HEAD' ? "head" : "article";
     my $art = $nntp->$get("<$groupart>");
     unless ($art) {
 	$nntp->quit; $nntp = undef;
 	$response->code(&HTTP::Status::RC_NOT_FOUND);
 	$response->message($nntp->message);
 	return $response;
     }
 
     my($key, $val);
     local $_;
     while ($_ = shift @$art) {
 	if (/^\s+$/) {
 	    last;  
 	}
 	elsif (/^(\S+):\s*(.*)/) {
 	    $response->push_header($key, $val) if $key;
 	    ($key, $val) = ($1, $2);
 	}
 	elsif (/^\s+(.*)/) {
 	    next unless $key;
 	    $val .= $1;
 	}
 	else {
 	    unshift(@$art, $_);
 	    last;
 	}
     }
     $response->push_header($key, $val) if $key;
 
     $response->header("Content-Type", "text/plain")
 	unless $response->header("Content-Type");
 
     $response = $self->collect_once($arg, $response, join("", @$art))
       if @$art;
 
     $nntp->quit;
     $nntp = undef;
 
     $response;
 }
 
 1;
### LWP/Protocol/nogo.pm ###
 package LWP::Protocol::nogo;
 
 use strict;
 use vars qw(@ISA);
 require HTTP::Response;
 require HTTP::Status;
 require LWP::Protocol;
 @ISA = qw(LWP::Protocol);
 
 sub request {
     my($self, $request) = @_;
     my $scheme = $request->uri->scheme;
     
     return HTTP::Response->new(
       &HTTP::Status::RC_INTERNAL_SERVER_ERROR,
       "Access to \'$scheme\' URIs has been disabled"
     );
 }
 1;
### LWP/RobotUA.pm ###
 package LWP::RobotUA;
 
 require LWP::UserAgent;
 @ISA = qw(LWP::UserAgent);
 $VERSION = "6.13";
 
 require WWW::RobotRules;
 require HTTP::Request;
 require HTTP::Response;
 
 use Carp ();
 use HTTP::Status ();
 use HTTP::Date qw(time2str);
 use strict;
 
 
 
 sub new
 {
     my $class = shift;
     my %cnf;
     if (@_ < 4) {
 	@cnf{qw(agent from rules)} = @_;
     }
     else {
 	%cnf = @_;
     }
 
     Carp::croak('LWP::RobotUA agent required') unless $cnf{agent};
     Carp::croak('LWP::RobotUA from address required')
 	unless $cnf{from} && $cnf{from} =~ m/\@/;
 
     my $delay = delete $cnf{delay} || 1;
     my $use_sleep = delete $cnf{use_sleep};
     $use_sleep = 1 unless defined($use_sleep);
     my $rules = delete $cnf{rules};
 
     my $self = LWP::UserAgent->new(%cnf);
     $self = bless $self, $class;
 
     $self->{'delay'} = $delay;   
     $self->{'use_sleep'} = $use_sleep;
 
     if ($rules) {
 	$rules->agent($cnf{agent});
 	$self->{'rules'} = $rules;
     }
     else {
 	$self->{'rules'} = WWW::RobotRules->new($cnf{agent});
     }
 
     $self;
 }
 
 
 sub delay     { shift->_elem('delay',     @_); }
 sub use_sleep { shift->_elem('use_sleep', @_); }
 
 
 sub agent
 {
     my $self = shift;
     my $old = $self->SUPER::agent(@_);
     if (@_) {
 	$self->{'rules'}->agent($self->{'agent'}); 
     }
     $old;
 }
 
 
 sub rules {
     my $self = shift;
     my $old = $self->_elem('rules', @_);
     $self->{'rules'}->agent($self->{'agent'}) if @_;
     $old;
 }
 
 
 sub no_visits
 {
     my($self, $netloc) = @_;
     $self->{'rules'}->no_visits($netloc) || 0;
 }
 
 *host_count = \&no_visits;  
 
 
 sub host_wait
 {
     my($self, $netloc) = @_;
     return undef unless defined $netloc;
     my $last = $self->{'rules'}->last_visit($netloc);
     if ($last) {
 	my $wait = int($self->{'delay'} * 60 - (time - $last));
 	$wait = 0 if $wait < 0;
 	return $wait;
     }
     return 0;
 }
 
 
 sub simple_request
 {
     my($self, $request, $arg, $size) = @_;
 
     my $allowed = $self->{'rules'}->allowed($request->uri);
 
     if ($allowed < 0) {
 	my $robot_url = $request->uri->clone;
 	$robot_url->path("robots.txt");
 	$robot_url->query(undef);
 
 	$self->{'rules'}->parse($robot_url, ""); 
 
 	my $robot_req = HTTP::Request->new('GET', $robot_url);
 	my $parse_head = $self->parse_head(0);
 	my $robot_res = $self->request($robot_req);
 	$self->parse_head($parse_head);
 	my $fresh_until = $robot_res->fresh_until;
 	my $content = "";
 	if ($robot_res->is_success && $robot_res->content_is_text) {
 	    $content = $robot_res->decoded_content;
 	    $content = "" unless $content && $content =~ /^\s*Disallow\s*:/mi;
 	}
 	$self->{'rules'}->parse($robot_url, $content, $fresh_until);
 
 	$allowed = $self->{'rules'}->allowed($request->uri);
     }
 
     unless ($allowed) {
 	my $res = HTTP::Response->new(
 	  &HTTP::Status::RC_FORBIDDEN, 'Forbidden by robots.txt');
 	$res->request( $request ); 
 	return $res;
     }
 
     my $netloc = eval { local $SIG{__DIE__}; $request->uri->host_port; };
     my $wait = $self->host_wait($netloc);
 
     if ($wait) {
 	if ($self->{'use_sleep'}) {
 	    sleep($wait)
 	}
 	else {
 	    my $res = HTTP::Response->new(
 	      &HTTP::Status::RC_SERVICE_UNAVAILABLE, 'Please, slow down');
 	    $res->header('Retry-After', time2str(time + $wait));
 	    $res->request( $request ); 
 	    return $res;
 	}
     }
 
     my $res = $self->SUPER::simple_request($request, $arg, $size);
 
     $self->{'rules'}->visit($netloc);
 
     $res;
 }
 
 
 sub as_string
 {
     my $self = shift;
     my @s;
     push(@s, "Robot: $self->{'agent'} operated by $self->{'from'}  [$self]");
     push(@s, "    Minimum delay: " . int($self->{'delay'}*60) . "s");
     push(@s, "    Will sleep if too early") if $self->{'use_sleep'};
     push(@s, "    Rules = $self->{'rules'}");
     join("\n", @s, '');
 }
 
 1;
 
 
 __END__
 
### LWP/Simple.pm ###
 package LWP::Simple;
 
 use strict;
 use vars qw($ua %loop_check $FULL_LWP @EXPORT @EXPORT_OK $VERSION);
 
 require Exporter;
 
 @EXPORT = qw(get head getprint getstore mirror);
 @EXPORT_OK = qw($ua);
 
 use HTTP::Status;
 push(@EXPORT, @HTTP::Status::EXPORT);
 
 $VERSION = "6.13";
 
 sub import
 {
     my $pkg = shift;
     my $callpkg = caller;
     Exporter::export($pkg, $callpkg, @_);
 }
 
 use LWP::UserAgent ();
 use HTTP::Status ();
 use HTTP::Date ();
 $ua = LWP::UserAgent->new;  
 $ua->agent("LWP::Simple/$VERSION ");
 $ua->env_proxy;
 
 
 sub get ($)
 {
     my $response = $ua->get(shift);
     return $response->decoded_content if $response->is_success;
     return undef;
 }
 
 
 sub head ($)
 {
     my($url) = @_;
     my $request = HTTP::Request->new(HEAD => $url);
     my $response = $ua->request($request);
 
     if ($response->is_success) {
 	return $response unless wantarray;
 	return (scalar $response->header('Content-Type'),
 		scalar $response->header('Content-Length'),
 		HTTP::Date::str2time($response->header('Last-Modified')),
 		HTTP::Date::str2time($response->header('Expires')),
 		scalar $response->header('Server'),
 	       );
     }
     return;
 }
 
 
 sub getprint ($)
 {
     my($url) = @_;
     my $request = HTTP::Request->new(GET => $url);
     local($\) = ""; 
     my $callback = sub { print $_[0] };
     if ($^O eq "MacOS") {
 	$callback = sub { $_[0] =~ s/\015?\012/\n/g; print $_[0] }
     }
     my $response = $ua->request($request, $callback);
     unless ($response->is_success) {
 	print STDERR $response->status_line, " <URL:$url>\n";
     }
     $response->code;
 }
 
 
 sub getstore ($$)
 {
     my($url, $file) = @_;
     my $request = HTTP::Request->new(GET => $url);
     my $response = $ua->request($request, $file);
 
     $response->code;
 }
 
 
 sub mirror ($$)
 {
     my($url, $file) = @_;
     my $response = $ua->mirror($url, $file);
     $response->code;
 }
 
 
 1;
 
 __END__
 
### LWP/UserAgent.pm ###
 package LWP::UserAgent;
 
 use strict;
 use vars qw(@ISA $VERSION);
 
 require LWP::MemberMixin;
 @ISA = qw(LWP::MemberMixin);
 $VERSION = "6.13";
 
 use HTTP::Request ();
 use HTTP::Response ();
 use HTTP::Date ();
 
 use LWP ();
 use LWP::Protocol ();
 
 use Carp ();
 
 
 sub new
 {
     Carp::croak("Options to LWP::UserAgent should be key/value pairs, not hash reference") 
         if ref($_[1]) eq 'HASH'; 
 
     my($class, %cnf) = @_;
 
     my $agent = delete $cnf{agent};
     my $from  = delete $cnf{from};
     my $def_headers = delete $cnf{default_headers};
     my $timeout = delete $cnf{timeout};
     $timeout = 3*60 unless defined $timeout;
     my $local_address = delete $cnf{local_address};
     my $ssl_opts = delete $cnf{ssl_opts} || {};
     unless (exists $ssl_opts->{verify_hostname}) {
 	if (exists $ENV{PERL_LWP_SSL_VERIFY_HOSTNAME}) {
 	    $ssl_opts->{verify_hostname} = $ENV{PERL_LWP_SSL_VERIFY_HOSTNAME};
 	}
 	elsif ($ENV{HTTPS_CA_FILE} || $ENV{HTTPS_CA_DIR}) {
 	    $ssl_opts->{verify_hostname} = 0;
 	    $ssl_opts->{SSL_verify_mode} = 1;
 	}
 	else {
 	    $ssl_opts->{verify_hostname} = 1;
 	}
     }
     unless (exists $ssl_opts->{SSL_ca_file}) {
 	if (my $ca_file = $ENV{PERL_LWP_SSL_CA_FILE} || $ENV{HTTPS_CA_FILE}) {
 	    $ssl_opts->{SSL_ca_file} = $ca_file;
 	}
     }
     unless (exists $ssl_opts->{SSL_ca_path}) {
 	if (my $ca_path = $ENV{PERL_LWP_SSL_CA_PATH} || $ENV{HTTPS_CA_DIR}) {
 	    $ssl_opts->{SSL_ca_path} = $ca_path;
 	}
     }
     my $use_eval = delete $cnf{use_eval};
     $use_eval = 1 unless defined $use_eval;
     my $parse_head = delete $cnf{parse_head};
     $parse_head = 1 unless defined $parse_head;
     my $show_progress = delete $cnf{show_progress};
     my $max_size = delete $cnf{max_size};
     my $max_redirect = delete $cnf{max_redirect};
     $max_redirect = 7 unless defined $max_redirect;
     my $env_proxy = exists $cnf{env_proxy} ? delete $cnf{env_proxy} : $ENV{PERL_LWP_ENV_PROXY};
 
     my $cookie_jar = delete $cnf{cookie_jar};
     my $conn_cache = delete $cnf{conn_cache};
     my $keep_alive = delete $cnf{keep_alive};
     
     Carp::croak("Can't mix conn_cache and keep_alive")
 	  if $conn_cache && $keep_alive;
 
     my $protocols_allowed   = delete $cnf{protocols_allowed};
     my $protocols_forbidden = delete $cnf{protocols_forbidden};
     
     my $requests_redirectable = delete $cnf{requests_redirectable};
     $requests_redirectable = ['GET', 'HEAD']
       unless defined $requests_redirectable;
 
     Carp::croak("protocols_allowed has to be an arrayref or 0, not \"$protocols_allowed\"!")
       if $protocols_allowed and ref($protocols_allowed) ne 'ARRAY';
     Carp::croak("protocols_forbidden has to be an arrayref or 0, not \"$protocols_forbidden\"!")
       if $protocols_forbidden and ref($protocols_forbidden) ne 'ARRAY';
     Carp::croak("requests_redirectable has to be an arrayref or 0, not \"$requests_redirectable\"!")
       if $requests_redirectable and ref($requests_redirectable) ne 'ARRAY';
 
 
     if (%cnf && $^W) {
 	Carp::carp("Unrecognized LWP::UserAgent options: @{[sort keys %cnf]}");
     }
 
     my $self = bless {
 		      def_headers  => $def_headers,
 		      timeout      => $timeout,
 		      local_address => $local_address,
 		      ssl_opts     => $ssl_opts,
 		      use_eval     => $use_eval,
                       show_progress=> $show_progress,
 		      max_size     => $max_size,
 		      max_redirect => $max_redirect,
                       proxy        => {},
 		      no_proxy     => [],
                       protocols_allowed     => $protocols_allowed,
                       protocols_forbidden   => $protocols_forbidden,
                       requests_redirectable => $requests_redirectable,
 		     }, $class;
 
     $self->agent(defined($agent) ? $agent : $class->_agent)
 	if defined($agent) || !$def_headers || !$def_headers->header("User-Agent");
     $self->from($from) if $from;
     $self->cookie_jar($cookie_jar) if $cookie_jar;
     $self->parse_head($parse_head);
     $self->env_proxy if $env_proxy;
 
     $self->protocols_allowed(  $protocols_allowed  ) if $protocols_allowed;
     $self->protocols_forbidden($protocols_forbidden) if $protocols_forbidden;
 
     if ($keep_alive) {
 	$conn_cache ||= { total_capacity => $keep_alive };
     }
     $self->conn_cache($conn_cache) if $conn_cache;
 
     return $self;
 }
 
 
 sub send_request
 {
     my($self, $request, $arg, $size) = @_;
     my($method, $url) = ($request->method, $request->uri);
     my $scheme = $url->scheme;
 
     local($SIG{__DIE__});  
 
     $self->progress("begin", $request);
 
     my $response = $self->run_handlers("request_send", $request);
 
     unless ($response) {
         my $protocol;
 
         {
             my $x;
             if($x = $self->protocols_allowed) {
                 if (grep lc($_) eq $scheme, @$x) {
                 }
                 else {
                     require LWP::Protocol::nogo;
                     $protocol = LWP::Protocol::nogo->new;
                 }
             }
             elsif ($x = $self->protocols_forbidden) {
                 if(grep lc($_) eq $scheme, @$x) {
                     require LWP::Protocol::nogo;
                     $protocol = LWP::Protocol::nogo->new;
                 }
             }
         }
 
         my $proxy = $request->{proxy};
         if ($proxy) {
             $scheme = $proxy->scheme;
         }
 
         unless ($protocol) {
             $protocol = eval { LWP::Protocol::create($scheme, $self) };
             if ($@) {
                 $@ =~ s/ at .* line \d+.*//s;  
                 $response =  _new_response($request, &HTTP::Status::RC_NOT_IMPLEMENTED, $@);
                 if ($scheme eq "https") {
                     $response->message($response->message . " (LWP::Protocol::https not installed)");
                     $response->content_type("text/plain");
                     $response->content(<<EOT);
 LWP will support https URLs if the LWP::Protocol::https module
 is installed.
 EOT
                 }
             }
         }
 
         if (!$response && $self->{use_eval}) {
             eval {
                 $response = $protocol->request($request, $proxy, $arg, $size, $self->{timeout}) ||
 		    die "No response returned by $protocol";
             };
             if ($@) {
                 if (UNIVERSAL::isa($@, "HTTP::Response")) {
                     $response = $@;
                     $response->request($request);
                 }
                 else {
                     my $full = $@;
                     (my $status = $@) =~ s/\n.*//s;
                     $status =~ s/ at .* line \d+.*//s;  
                     my $code = ($status =~ s/^(\d\d\d)\s+//) ? $1 : &HTTP::Status::RC_INTERNAL_SERVER_ERROR;
                     $response = _new_response($request, $code, $status, $full);
                 }
             }
         }
         elsif (!$response) {
             $response = $protocol->request($request, $proxy,
                                            $arg, $size, $self->{timeout});
         }
     }
 
     $response->request($request);  
     $response->header("Client-Date" => HTTP::Date::time2str(time));
 
     $self->run_handlers("response_done", $response);
 
     $self->progress("end", $response);
     return $response;
 }
 
 
 sub prepare_request
 {
     my($self, $request) = @_;
     die "Method missing" unless $request->method;
     my $url = $request->uri;
     die "URL missing" unless $url;
     die "URL must be absolute" unless $url->scheme;
 
     $self->run_handlers("request_preprepare", $request);
 
     if (my $def_headers = $self->{def_headers}) {
 	for my $h ($def_headers->header_field_names) {
 	    $request->init_header($h => [$def_headers->header($h)]);
 	}
     }
 
     $self->run_handlers("request_prepare", $request);
 
     return $request;
 }
 
 
 sub simple_request
 {
     my($self, $request, $arg, $size) = @_;
 
     if (defined $request) {
 	if (ref $request) {
 	    Carp::croak("You need a request object, not a " . ref($request) . " object")
 	      if ref($request) eq 'ARRAY' or ref($request) eq 'HASH' or
 		 !$request->can('method') or !$request->can('uri');
 	}
 	else {
 	    Carp::croak("You need a request object, not '$request'");
 	}
     }
     else {
         Carp::croak("No request object passed in");
     }
 
     eval {
 	$request = $self->prepare_request($request);
     };
     if ($@) {
 	$@ =~ s/ at .* line \d+.*//s;  
 	return _new_response($request, &HTTP::Status::RC_BAD_REQUEST, $@);
     }
     return $self->send_request($request, $arg, $size);
 }
 
 
 sub request
 {
     my($self, $request, $arg, $size, $previous) = @_;
 
     my $response = $self->simple_request($request, $arg, $size);
     $response->previous($previous) if $previous;
 
     if ($response->redirects >= $self->{max_redirect}) {
         $response->header("Client-Warning" =>
                           "Redirect loop detected (max_redirect = $self->{max_redirect})");
         return $response;
     }
 
     if (my $req = $self->run_handlers("response_redirect", $response)) {
         return $self->request($req, $arg, $size, $response);
     }
 
     my $code = $response->code;
 
     if ($code == &HTTP::Status::RC_MOVED_PERMANENTLY or
 	$code == &HTTP::Status::RC_FOUND or
 	$code == &HTTP::Status::RC_SEE_OTHER or
 	$code == &HTTP::Status::RC_TEMPORARY_REDIRECT)
     {
 	my $referral = $request->clone;
 
 	$referral->remove_header('Host', 'Cookie');
 	
 	if ($referral->header('Referer') &&
 	    $request->uri->scheme eq 'https' &&
 	    $referral->uri->scheme eq 'http')
 	{
 	    $referral->remove_header('Referer');
 	}
 
 	if ($code == &HTTP::Status::RC_SEE_OTHER ||
 	    $code == &HTTP::Status::RC_FOUND) 
         {
 	    my $method = uc($referral->method);
 	    unless ($method eq "GET" || $method eq "HEAD") {
 		$referral->method("GET");
 		$referral->content("");
 		$referral->remove_content_headers;
 	    }
 	}
 
 	my $referral_uri = $response->header('Location');
 	{
 	    local $URI::ABS_ALLOW_RELATIVE_SCHEME = 1;
 	    my $base = $response->base;
 	    $referral_uri = "" unless defined $referral_uri;
 	    $referral_uri = $HTTP::URI_CLASS->new($referral_uri, $base)
 		            ->abs($base);
 	}
 	$referral->uri($referral_uri);
 
 	return $response unless $self->redirect_ok($referral, $response);
 	return $self->request($referral, $arg, $size, $response);
 
     }
     elsif ($code == &HTTP::Status::RC_UNAUTHORIZED ||
 	     $code == &HTTP::Status::RC_PROXY_AUTHENTICATION_REQUIRED
 	    )
     {
 	my $proxy = ($code == &HTTP::Status::RC_PROXY_AUTHENTICATION_REQUIRED);
 	my $ch_header = $proxy || $request->method eq 'CONNECT'
 	    ?  "Proxy-Authenticate" : "WWW-Authenticate";
 	my @challenge = $response->header($ch_header);
 	unless (@challenge) {
 	    $response->header("Client-Warning" => 
 			      "Missing Authenticate header");
 	    return $response;
 	}
 
 	require HTTP::Headers::Util;
 	CHALLENGE: for my $challenge (@challenge) {
 	    $challenge =~ tr/,/;/;  
 	    ($challenge) = HTTP::Headers::Util::split_header_words($challenge);
 	    my $scheme = shift(@$challenge);
 	    shift(@$challenge); 
 	    $challenge = { @$challenge };  
 
 	    unless ($scheme =~ /^([a-z]+(?:-[a-z]+)*)$/) {
 		$response->header("Client-Warning" => 
 				  "Bad authentication scheme '$scheme'");
 		return $response;
 	    }
 	    $scheme = $1;  
 	    my $class = "LWP::Authen::\u$scheme";
 	    $class =~ s/-/_/g;
 
 	    no strict 'refs';
 	    unless (%{"$class\::"}) {
 		eval "require $class";
 		if ($@) {
 		    if ($@ =~ /^Can\'t locate/) {
 			$response->header("Client-Warning" =>
 					  "Unsupported authentication scheme '$scheme'");
 		    }
 		    else {
 			$response->header("Client-Warning" => $@);
 		    }
 		    next CHALLENGE;
 		}
 	    }
 	    unless ($class->can("authenticate")) {
 		$response->header("Client-Warning" =>
 				  "Unsupported authentication scheme '$scheme'");
 		next CHALLENGE;
 	    }
 	    return $class->authenticate($self, $proxy, $challenge, $response,
 					$request, $arg, $size);
 	}
 	return $response;
     }
     return $response;
 }
 
 
 sub get {
     require HTTP::Request::Common;
     my($self, @parameters) = @_;
     my @suff = $self->_process_colonic_headers(\@parameters,1);
     return $self->request( HTTP::Request::Common::GET( @parameters ), @suff );
 }
 
 
 sub post {
     require HTTP::Request::Common;
     my($self, @parameters) = @_;
     my @suff = $self->_process_colonic_headers(\@parameters, (ref($parameters[1]) ? 2 : 1));
     return $self->request( HTTP::Request::Common::POST( @parameters ), @suff );
 }
 
 
 sub head {
     require HTTP::Request::Common;
     my($self, @parameters) = @_;
     my @suff = $self->_process_colonic_headers(\@parameters,1);
     return $self->request( HTTP::Request::Common::HEAD( @parameters ), @suff );
 }
 
 
 sub put {
     require HTTP::Request::Common;
     my($self, @parameters) = @_;
     my @suff = $self->_process_colonic_headers(\@parameters, (ref($parameters[1]) ? 2 : 1));
     return $self->request( HTTP::Request::Common::PUT( @parameters ), @suff );
 }
 
 
 sub delete {
     require HTTP::Request::Common;
     my($self, @parameters) = @_;
     my @suff = $self->_process_colonic_headers(\@parameters,1);
     return $self->request( HTTP::Request::Common::DELETE( @parameters ), @suff );
 }
 
 
 sub _process_colonic_headers {
     my($self, $args, $start_index) = @_;
 
     my($arg, $size);
     for(my $i = $start_index; $i < @$args; $i += 2) {
 	next unless defined $args->[$i];
 
 
 	if($args->[$i] eq ':content_cb') {
 	    $arg = $args->[$i + 1];
 	    Carp::croak("A :content_cb value can't be undef") unless defined $arg;
 	    Carp::croak("A :content_cb value must be a coderef")
 		unless ref $arg and UNIVERSAL::isa($arg, 'CODE');
 	    
 	}
 	elsif ($args->[$i] eq ':content_file') {
 	    $arg = $args->[$i + 1];
 
 	    Carp::croak("A :content_file value can't be undef")
 		unless defined $arg;
 	    Carp::croak("A :content_file value can't be a reference")
 		if ref $arg;
 	    Carp::croak("A :content_file value can't be \"\"")
 		unless length $arg;
 
 	}
 	elsif ($args->[$i] eq ':read_size_hint') {
 	    $size = $args->[$i + 1];
 
 	}
 	else {
 	    next;
 	}
 	splice @$args, $i, 2;
 	$i -= 2;
     }
 
 
     return             unless defined $arg;
     return $arg, $size if     defined $size;
     return $arg;
 }
 
 
 sub is_online {
     my $self = shift;
     return 1 if $self->get("http://www.msftncsi.com/ncsi.txt")->content eq "Microsoft NCSI";
     return 1 if $self->get("http://www.apple.com")->content =~ m,<title>Apple</title>,;
     return 0;
 }
 
 
 my @ANI = qw(- \ | /);
 
 sub progress {
     my($self, $status, $m) = @_;
     return unless $self->{show_progress};
 
     local($,, $\);
     if ($status eq "begin") {
         print STDERR "** ", $m->method, " ", $m->uri, " ==> ";
         $self->{progress_start} = time;
         $self->{progress_lastp} = "";
         $self->{progress_ani} = 0;
     }
     elsif ($status eq "end") {
         delete $self->{progress_lastp};
         delete $self->{progress_ani};
         print STDERR $m->status_line;
         my $t = time - delete $self->{progress_start};
         print STDERR " (${t}s)" if $t;
         print STDERR "\n";
     }
     elsif ($status eq "tick") {
         print STDERR "$ANI[$self->{progress_ani}++]\b";
         $self->{progress_ani} %= @ANI;
     }
     else {
         my $p = sprintf "%3.0f%%", $status * 100;
         return if $p eq $self->{progress_lastp};
         print STDERR "$p\b\b\b\b";
         $self->{progress_lastp} = $p;
     }
     STDERR->flush;
 }
 
 
 sub is_protocol_supported
 {
     my($self, $scheme) = @_;
     if (ref $scheme) {
 	$scheme = $scheme->scheme;
     }
     else {
 	Carp::croak("Illegal scheme '$scheme' passed to is_protocol_supported")
 	    if $scheme =~ /\W/;
 	$scheme = lc $scheme;
     }
 
     my $x;
     if(ref($self) and $x       = $self->protocols_allowed) {
       return 0 unless grep lc($_) eq $scheme, @$x;
     }
     elsif (ref($self) and $x = $self->protocols_forbidden) {
       return 0 if grep lc($_) eq $scheme, @$x;
     }
 
     local($SIG{__DIE__});  
     $x = LWP::Protocol::implementor($scheme);
     return 1 if $x and $x ne 'LWP::Protocol::nogo';
     return 0;
 }
 
 
 sub protocols_allowed      { shift->_elem('protocols_allowed'    , @_) }
 sub protocols_forbidden    { shift->_elem('protocols_forbidden'  , @_) }
 sub requests_redirectable  { shift->_elem('requests_redirectable', @_) }
 
 
 sub redirect_ok
 {
 
 
     my($self, $new_request, $response) = @_;
     my $method = $response->request->method;
     return 0 unless grep $_ eq $method,
       @{ $self->requests_redirectable || [] };
     
     if ($new_request->uri->scheme eq 'file') {
       $response->header("Client-Warning" =>
 			"Can't redirect to a file:// URL!");
       return 0;
     }
     
     return 1;
 }
 
 
 sub credentials
 {
     my $self = shift;
     my $netloc = lc(shift);
     my $realm = shift || "";
     my $old = $self->{basic_authentication}{$netloc}{$realm};
     if (@_) {
         $self->{basic_authentication}{$netloc}{$realm} = [@_];
     }
     return unless $old;
     return @$old if wantarray;
     return join(":", @$old);
 }
 
 
 sub get_basic_credentials
 {
     my($self, $realm, $uri, $proxy) = @_;
     return if $proxy;
     return $self->credentials($uri->host_port, $realm);
 }
 
 
 sub timeout      { shift->_elem('timeout',      @_); }
 sub local_address{ shift->_elem('local_address',@_); }
 sub max_size     { shift->_elem('max_size',     @_); }
 sub max_redirect { shift->_elem('max_redirect', @_); }
 sub show_progress{ shift->_elem('show_progress', @_); }
 
 sub ssl_opts {
     my $self = shift;
     if (@_ == 1) {
 	my $k = shift;
 	return $self->{ssl_opts}{$k};
     }
     if (@_) {
 	my $old;
 	while (@_) {
 	    my($k, $v) = splice(@_, 0, 2);
 	    $old = $self->{ssl_opts}{$k} unless @_;
 	    if (defined $v) {
 		$self->{ssl_opts}{$k} = $v;
 	    }
 	    else {
 		delete $self->{ssl_opts}{$k};
 	    }
 	}
 	%{$self->{ssl_opts}} = (%{$self->{ssl_opts}}, @_);
 	return $old;
     }
 
     return keys %{$self->{ssl_opts}};
 }
 
 sub parse_head {
     my $self = shift;
     if (@_) {
         my $flag = shift;
         my $parser;
         my $old = $self->set_my_handler("response_header", $flag ? sub {
                my($response, $ua) = @_;
                require HTML::HeadParser;
                $parser = HTML::HeadParser->new;
                $parser->xml_mode(1) if $response->content_is_xhtml;
                $parser->utf8_mode(1) if $] >= 5.008 && $HTML::Parser::VERSION >= 3.40;
 
                push(@{$response->{handlers}{response_data}}, {
 		   callback => sub {
 		       return unless $parser;
 		       unless ($parser->parse($_[3])) {
 			   my $h = $parser->header;
 			   my $r = $_[0];
 			   for my $f ($h->header_field_names) {
 			       $r->init_header($f, [$h->header($f)]);
 			   }
 			   undef($parser);
 		       }
 		   },
 	       });
 
             } : undef,
             m_media_type => "html",
         );
         return !!$old;
     }
     else {
         return !!$self->get_my_handler("response_header");
     }
 }
 
 sub cookie_jar {
     my $self = shift;
     my $old = $self->{cookie_jar};
     if (@_) {
 	my $jar = shift;
 	if (ref($jar) eq "HASH") {
 	    require HTTP::Cookies;
 	    $jar = HTTP::Cookies->new(%$jar);
 	}
 	$self->{cookie_jar} = $jar;
         $self->set_my_handler("request_prepare",
             $jar ? sub { $jar->add_cookie_header($_[0]); } : undef,
         );
         $self->set_my_handler("response_done",
             $jar ? sub { $jar->extract_cookies($_[0]); } : undef,
         );
     }
     $old;
 }
 
 sub default_headers {
     my $self = shift;
     my $old = $self->{def_headers} ||= HTTP::Headers->new;
     if (@_) {
 	Carp::croak("default_headers not set to HTTP::Headers compatible object")
 	    unless @_ == 1 && $_[0]->can("header_field_names");
 	$self->{def_headers} = shift;
     }
     return $old;
 }
 
 sub default_header {
     my $self = shift;
     return $self->default_headers->header(@_);
 }
 
 sub _agent       { "libwww-perl/$LWP::VERSION" }
 
 sub agent {
     my $self = shift;
     if (@_) {
 	my $agent = shift;
         if ($agent) {
             $agent .= $self->_agent if $agent =~ /\s+$/;
         }
         else {
             undef($agent)
         }
         return $self->default_header("User-Agent", $agent);
     }
     return $self->default_header("User-Agent");
 }
 
 sub from {  
     my $self = shift;
     return $self->default_header("From", @_);
 }
 
 
 sub conn_cache {
     my $self = shift;
     my $old = $self->{conn_cache};
     if (@_) {
 	my $cache = shift;
 	if (ref($cache) eq "HASH") {
 	    require LWP::ConnCache;
 	    $cache = LWP::ConnCache->new(%$cache);
 	}
 	$self->{conn_cache} = $cache;
     }
     $old;
 }
 
 
 sub add_handler {
     my($self, $phase, $cb, %spec) = @_;
     $spec{line} ||= join(":", (caller)[1,2]);
     my $conf = $self->{handlers}{$phase} ||= do {
         require HTTP::Config;
         HTTP::Config->new;
     };
     $conf->add(%spec, callback => $cb);
 }
 
 sub set_my_handler {
     my($self, $phase, $cb, %spec) = @_;
     $spec{owner} = (caller(1))[3] unless exists $spec{owner};
     $self->remove_handler($phase, %spec);
     $spec{line} ||= join(":", (caller)[1,2]);
     $self->add_handler($phase, $cb, %spec) if $cb;
 }
 
 sub get_my_handler {
     my $self = shift;
     my $phase = shift;
     my $init = pop if @_ % 2;
     my %spec = @_;
     my $conf = $self->{handlers}{$phase};
     unless ($conf) {
         return unless $init;
         require HTTP::Config;
         $conf = $self->{handlers}{$phase} = HTTP::Config->new;
     }
     $spec{owner} = (caller(1))[3] unless exists $spec{owner};
     my @h = $conf->find(%spec);
     if (!@h && $init) {
         if (ref($init) eq "CODE") {
             $init->(\%spec);
         }
         elsif (ref($init) eq "HASH") {
             while (my($k, $v) = each %$init) {
                 $spec{$k} = $v;
             }
         }
         $spec{callback} ||= sub {};
         $spec{line} ||= join(":", (caller)[1,2]);
         $conf->add(\%spec);
         return \%spec;
     }
     return wantarray ? @h : $h[0];
 }
 
 sub remove_handler {
     my($self, $phase, %spec) = @_;
     if ($phase) {
         my $conf = $self->{handlers}{$phase} || return;
         my @h = $conf->remove(%spec);
         delete $self->{handlers}{$phase} if $conf->empty;
         return @h;
     }
 
     return unless $self->{handlers};
     return map $self->remove_handler($_), sort keys %{$self->{handlers}};
 }
 
 sub handlers {
     my($self, $phase, $o) = @_;
     my @h;
     if ($o->{handlers} && $o->{handlers}{$phase}) {
         push(@h, @{$o->{handlers}{$phase}});
     }
     if (my $conf = $self->{handlers}{$phase}) {
         push(@h, $conf->matching($o));
     }
     return @h;
 }
 
 sub run_handlers {
     my($self, $phase, $o) = @_;
     if (defined(wantarray)) {
         for my $h ($self->handlers($phase, $o)) {
             my $ret = $h->{callback}->($o, $self, $h);
             return $ret if $ret;
         }
         return undef;
     }
 
     for my $h ($self->handlers($phase, $o)) {
         $h->{callback}->($o, $self, $h);
     }
 }
 
 
 sub use_eval   { shift->_elem('use_eval',  @_); }
 sub use_alarm
 {
     Carp::carp("LWP::UserAgent->use_alarm(BOOL) is a no-op")
 	if @_ > 1 && $^W;
     "";
 }
 
 
 sub clone
 {
     my $self = shift;
     my $copy = bless { %$self }, ref $self;  
 
     delete $copy->{handlers};
     delete $copy->{conn_cache};
 
     for my $k (qw(proxy no_proxy requests_redirectable ssl_opts)) {
         next unless $copy->{$k};
         if (ref($copy->{$k}) eq "ARRAY") {
             $copy->{$k} = [ @{$copy->{$k}} ];
         }
         elsif (ref($copy->{$k}) eq "HASH") {
             $copy->{$k} = { %{$copy->{$k}} };
         }
     }
 
     if ($self->{def_headers}) {
         $copy->{def_headers} = $self->{def_headers}->clone;
     }
 
     $copy->parse_head($self->parse_head);
 
     $copy->cookie_jar(undef);
 
     $copy;
 }
 
 
 sub mirror
 {
     my($self, $url, $file) = @_;
 
     my $request = HTTP::Request->new('GET', $url);
 
     if ( -e $file ) {
         my ($mtime) = ( stat($file) )[9];
         if ($mtime) {
             $request->header( 'If-Modified-Since' => HTTP::Date::time2str($mtime) );
         }
     }
     my $tmpfile = "$file-$$";
 
     my $response = $self->request($request, $tmpfile);
     if ( $response->header('X-Died') ) {
 	die $response->header('X-Died');
     }
 
     if ( $response->is_success ) {
         my @stat        = stat($tmpfile) or die "Could not stat tmpfile '$tmpfile': $!";
         my $file_length = $stat[7];
         my ($content_length) = $response->header('Content-length');
 
         if ( defined $content_length and $file_length < $content_length ) {
             unlink($tmpfile);
             die "Transfer truncated: " . "only $file_length out of $content_length bytes received\n";
         }
         elsif ( defined $content_length and $file_length > $content_length ) {
             unlink($tmpfile);
             die "Content-length mismatch: " . "expected $content_length bytes, got $file_length\n";
         }
         else {
             if ( -e $file ) {
                 chmod 0777, $file;
                 unlink $file;
             }
             rename( $tmpfile, $file )
                 or die "Cannot rename '$tmpfile' to '$file': $!\n";
 
             if ( my $lm = $response->last_modified ) {
                 utime $lm, $lm, $file;
             }
         }
     }
     else {
 	unlink($tmpfile);
     }
     return $response;
 }
 
 
 sub _need_proxy {
     my($req, $ua) = @_;
     return if exists $req->{proxy};
     my $proxy = $ua->{proxy}{$req->uri->scheme} || return;
     if ($ua->{no_proxy}) {
         if (my $host = eval { $req->uri->host }) {
             for my $domain (@{$ua->{no_proxy}}) {
                 if ($host =~ /\Q$domain\E$/) {
                     return;
                 }
             }
         }
     }
     $req->{proxy} = $HTTP::URI_CLASS->new($proxy);
 }
 
 
 sub proxy
 {
     my $self = shift;
     my $key  = shift;
     return map $self->proxy($_, @_), @$key if ref $key;
 
     Carp::croak("'$key' is not a valid URI scheme") unless $key =~ /^$URI::scheme_re\z/;
     my $old = $self->{'proxy'}{$key};
     if (@_) {
         my $url = shift;
         if (defined($url) && length($url)) {
             Carp::croak("Proxy must be specified as absolute URI; '$url' is not") unless $url =~ /^$URI::scheme_re:/;
             Carp::croak("Bad http proxy specification '$url'") if $url =~ /^https?:/ && $url !~ m,^https?://\w,;
         }
         $self->{proxy}{$key} = $url;
         $self->set_my_handler("request_preprepare", \&_need_proxy)
     }
     return $old;
 }
 
 
 sub env_proxy {
     my ($self) = @_;
     require Encode;
     require Encode::Locale;
     my($k,$v);
     while(($k, $v) = each %ENV) {
 	if ($ENV{REQUEST_METHOD}) {
 	    next if $k =~ /^HTTP_/;
 	    $k = "HTTP_PROXY" if $k eq "CGI_HTTP_PROXY";
 	}
 	$k = lc($k);
 	next unless $k =~ /^(.*)_proxy$/;
 	$k = $1;
 	if ($k eq 'no') {
 	    $self->no_proxy(split(/\s*,\s*/, $v));
 	}
 	else {
             next unless $k =~ /^$URI::scheme_re\z/;
             next unless LWP::Protocol::implementor($k);
 	    $self->proxy($k, Encode::decode(locale => $v));
 	}
     }
 }
 
 
 sub no_proxy {
     my($self, @no) = @_;
     if (@no) {
 	push(@{ $self->{'no_proxy'} }, @no);
     }
     else {
 	$self->{'no_proxy'} = [];
     }
 }
 
 
 sub _new_response {
     my($request, $code, $message, $content) = @_;
     $message ||= HTTP::Status::status_message($code);
     my $response = HTTP::Response->new($code, $message);
     $response->request($request);
     $response->header("Client-Date" => HTTP::Date::time2str(time));
     $response->header("Client-Warning" => "Internal response");
     $response->header("Content-Type" => "text/plain");
     $response->content($content || "$code $message\n");
     return $response;
 }
 
 
 1;
 
 __END__
 
### Lingua/EN/Numbers/Ordinate.pm ###
 package Lingua::EN::Numbers::Ordinate;
 $Lingua::EN::Numbers::Ordinate::VERSION = '1.04';
 
 use 5.006;
 use strict;
 use warnings;
 require Exporter;
 
 our @ISA        = qw/ Exporter  /;
 our @EXPORT     = qw/ ordinate  /;
 our @EXPORT_OK  = qw/ ordsuf th /;
 
 
 
 
 sub ordsuf ($) {
   return 'th' if not(defined($_[0])) or not( 0 + $_[0] );
   my $n = abs($_[0]);  
   return 'th' unless $n == int($n); 
   $n %= 100;
   return 'th' if $n == 11 or $n == 12 or $n == 13;
   $n %= 10;
   return 'st' if $n == 1; 
   return 'nd' if $n == 2;
   return 'rd' if $n == 3;
   return 'th';
 }
 
 sub ordinate ($) {
   my $i = $_[0] || 0;
   return $i . ordsuf($i);
 }
 
 no warnings 'all';
 *th = \&ordinate; 
 
 1;
 
 __END__
### Lingua/EN/PluralToSingular.pm ###
 package Lingua::EN::PluralToSingular;
 require Exporter;
 @ISA = qw(Exporter);
 @EXPORT_OK = qw/to_singular is_plural/;
 use warnings;
 use strict;
 our $VERSION = '0.16';
 
 
 
 
 my %irregular = (qw/
     analyses analysis
     children child
     corpora corpus
     craftsmen craftsman
     crises crisis
     criteria criterion
     curricula curriculum
     feet foot
     fungi fungus
     geese goose
     genera genus
     indices index
     lice louse
     matrices matrix
     memoranda memorandum
     men man
     mice mouse
     monies money
     neuroses neurosis
     nuclei nucleus
     oases oasis
     pence penny
     people person
     phenomena phenomenon
     quanta quantum
     strata stratum
     teeth tooth
     testes testis
     these this
     theses thesis
     those that
     women woman
 /);
 
 
 
 my %ves = (qw/
     calves calf
     dwarves dwarf
     elves elf
     halves half
     knives knife
     leaves leaf
     lives life
     loaves loaf
     scarves scarf
     sheaves sheaf
     shelves shelf
     wharves wharf 
     wives wife
     wolves wolf
 /);
 
 
 my %plural = (
     'menus' => 'menu',
     'buses' => 'bus',
     %ves,
     %irregular,
 );
 
 
 my @no_change = qw/
                       clothes
                       deer
                       ides
                       fish
                       means
                       offspring
                       series
                       sheep
                       species
                   /;
 
 @plural{@no_change} = @no_change;
 
 
 
 
 my @not_plural = (qw/
 			Charles
 			Gonzales 
 			Hades 
 			Hercules 
 			Hermes 
 			Holmes 
 			Hughes 
 			Ives 
 			Jacques 
 			James 
 			Keyes 
 			Mercedes 
 			Naples 
 			Oates 
 			Raines 
 			Texas
 			athletics
 			bogus
 			bus
 			cactus
 			cannabis
 			chaos
 			citrus
 			corps
 			corpus
 			devious
 			dias
 			famous
 			hippopotamus
 			homunculus
 			iris
 			lens
 			mathematics
 			metaphysics
 			metropolis
 			mews
 			minus
 			miscellaneous
 			molasses
 			mrs
 			narcissus
 			news
 			octopus
 			ourselves
 			papyrus
 			perhaps
 			physics
 			platypus
 			plus
 			previous
 			pus
 			sometimes
 			stylus
 			themselves
 			this
 			thus
 			various
 			yes
 		    /);
 
 my %not_plural;
 
 @not_plural{@not_plural} = (1) x @not_plural;
 
 
 
 
 
 my @oes = (qw/
 		 canoes
 		 does
 		 foes
 		 gumshoes
 		 horseshoes
 		 oboes
 		 shoes
 		 snowshoes
 		 throes
                  hoes
                  toes
              /);
 
 my %oes;
 
 @oes{@oes} = (1) x @oes;
 
 
 
 
 
 
 
 my @ies = (qw/
 Aussies
 Valkryies
 aunties
 bogie
 brownies
 calories
 charlies
 coolies
 coteries
 curies
 cuties
 dies
 genies
 goalie
 kilocalories
 lies
 magpies
 menagerie
 movies
 neckties
 pies
 porkpies
 prairies
 quickies
 reveries
 rookies
 sorties
 stogies
 talkies
 ties
 zombies
 /);
 
 my %ies;
 
 @ies{@ies} = (1) x @ies;
 
 
 my @ses = (qw/
 horses
 tenses
 /);
 
 my %ses;
 @ses{@ses} = (1) x @ses;
 
 
 my $es_re = qr/([^aeiou]s|ch|sh)es$/;
 
 
 sub to_singular
 {
     my ($word) = @_;
     my $singular = $word;
     if (! $not_plural{$word}) {
         if ($plural{$word}) {
             $singular = $plural{$word};
         }
         elsif ($word =~ /s$/) {
 	    if ($word =~ /'s$/) {
 		;
 	    }
 	    elsif (length ($word) <= 2) {
 		;
 	    }
 	    elsif ($word =~ /ss$/) {
 		;
 	    }
 	    elsif ($word =~ /sis$/) {
 		;
 	    }
             elsif ($word =~ /ies$/) {
                 if ($ies{$word}) {
                     $singular =~ s/ies$/ie/;
                 }
                 else {
                     $singular =~ s/ies$/y/;
                 }
             }
             elsif ($word =~ /oes$/) {
                 if ($oes{$word}) {
                     $singular =~ s/oes$/oe/;
                 }
                 else {
                     $singular =~ s/oes$/o/;
                 }
             }
             elsif ($word =~ /xes$/) {
 		$singular =~ s/xes$/x/;
             }
 	    elsif ($word =~ /ses$/) {
 		if ($ses{$word}) {
 		    $singular =~ s/ses$/se/;
 		}
 		else {
 		    $singular =~ s/ses$/s/;
 		}
 	    }
             elsif ($word =~ $es_re) {
                 $singular =~ s/$es_re/$1/;
             }
             else {
                 $singular =~ s/s$//;
             }
         }
     }            
     return $singular;
 }
 
 sub is_plural
 {
     my ($word) = @_;
     my $singular = to_singular ($word);
     my $is_plural;
     if ($singular ne $word) {
 	$is_plural = 1;
     }
     elsif ($plural{$singular} && $plural{$singular} eq $singular) {
 	$is_plural = 1;
     }
     else {
 	$is_plural = 0;
     }
     return $is_plural;
 }
 
 1;
 
### Locale/Messages.pm ###
 #! /bin/false
 
 
 
 
 
 
 package Locale::Messages;
 
 use strict;
 
 use vars qw ($package @EXPORT_OK %EXPORT_TAGS @ISA $VERSION);
 
 $VERSION = '1.24';
 
 $package = 'gettext_xs';
 eval <<'EOF';
 require Locale::gettext_xs; 
 my $version = Locale::gettext_xs::__gettext_xs_version();
 die "Version: version mismatch ($VERSION vs. $version)" unless $version eq $VERSION;
 EOF
 my $no_xs = $@;
 
 if ($no_xs) {
     eval {
         require POSIX;
         POSIX::setlocale(POSIX::LC_ALL());
     };
     if ($@) {
         $package = 'gettext_dumb';
         require Locale::gettext_dumb;
     } else {
         $package = 'gettext_pp';
         require Locale::gettext_pp;
     }
 }
 		
 require Exporter;
 @ISA = qw (Exporter);
 %EXPORT_TAGS = (locale_h => [ qw (gettext
 				  dgettext
 				  dcgettext
 				  ngettext
 				  dngettext
 				  dcngettext
 				  pgettext
 				  dpgettext
 				  dcpgettext
 				  npgettext
 				  dnpgettext
 				  dcnpgettext
 				  textdomain
 				  bindtextdomain
 				  bind_textdomain_codeset
 				  )
 			       ],
 		 libintl_h => [ qw (LC_CTYPE
 				    LC_NUMERIC
 				    LC_TIME
 				    LC_COLLATE
 				    LC_MONETARY
 				    LC_MESSAGES
 				    LC_ALL)
 				],
 		 );
 
 @EXPORT_OK = qw (select_package
 				 turn_utf_8_on
 				 turn_utf_8_off
 				 gettext
 				 dgettext
 				 dcgettext
 				 ngettext
 				 dngettext
 				 dcngettext
 				 pgettext
 				 dpgettext
 				 dcpgettext
 				 npgettext
 				 dnpgettext
 				 dcnpgettext
 				 textdomain
 				 bindtextdomain
 				 bind_textdomain_codeset
 				 bind_textdomain_filter
                  nl_putenv
                  setlocale
 				 LC_CTYPE
 				 LC_NUMERIC
 				 LC_TIME
 				 LC_COLLATE
 				 LC_MONETARY
 				 LC_MESSAGES
 				 LC_ALL);
 
 BEGIN {
 	my ($has_encode, $has_bytes);
 	
 	if ($] >= 5.006) {
 		unless (defined $has_encode) {
 			eval "require Encode";
 			$has_encode = !$@;
 		}
 
 		unless ($has_encode || defined $has_bytes) {
 			eval "use bytes";
 			$has_bytes = !$@;
 		}
 	}
 
 	if ($has_encode) {
 		eval <<'EOF';
 sub turn_utf_8_on($;$)
 {
 	Encode::_utf8_on ($_[0]);
 	return $_[0];
 }
 
 sub turn_utf_8_off($;$)
 {
 	Encode::_utf8_off ($_[0]);
 	return $_[0];
 }
 
 EOF
 	} elsif ($has_bytes) {
 		eval <<'EOF';
 sub turn_utf_8_on($;$)
 {
 	$_[0] = pack "U0C*", unpack "C*", $_[0];
 }
 
 sub turn_utf_8_off($;$)
 {
 	use bytes;
 	$_[0] = join "", split //, $_[0];
 }
 
 EOF
 	} else {
 		eval <<'EOF';
 sub turn_utf_8_on($;$)
 {
 	return $_[0];
 }
 
 sub turn_utf_8_off($;$)
 {
 	return $_[0];
 }
 
 EOF
 	}
 }
 
 my %filters = (undef => \&turn_utf_8_off);
 
 sub select_package {
     my ($pkg, $compatibility) = @_;
 
     if (__PACKAGE__ eq $pkg && defined $compatibility) {
         $pkg = $compatibility;
     }
 
     if ($no_xs && 'gettext_xs' eq $pkg) {
         $pkg = 'gettext_pp';
     }
 
     if (defined $pkg && 'gettext_pp' eq $pkg) {
         require Locale::gettext_pp;
         $package = 'gettext_pp';
     } elsif (defined $pkg) {
         my $filename = "Locale::$pkg";
         $filename =~ s{::|\'}{/};
 	$filename .= '.pm';
         eval { require $filename };
 	$package = $pkg unless $@;   
     } else {
         eval "require Locale::gettext_xs";
         $package = 'gettext_xs' unless $@;
     }
 
     return $package;
 }
 
 sub bind_textdomain_filter ($;$$) {
 	my ($textdomain, $coderef, $data) = @_;
 
 	$filters{$textdomain} = [ $coderef, $data ];
 
 	return 1;
 }
 
 sub textdomain (;$) {
     my $function = "Locale::${package}::textdomain";
     
     no strict 'refs';
     &$function;
 }
 
 sub bindtextdomain ($;$) {
     my $function = "Locale::${package}::bindtextdomain";
 
     no strict 'refs';
     &$function;
 }
 
 sub bind_textdomain_codeset ($;$) {
     my $function = "Locale::${package}::bind_textdomain_codeset";
 
     no strict 'refs';    
     &$function;
 }
 
 sub gettext ($) {
     my $textdomain = textdomain;
     $filters{$textdomain} ||= [ \&turn_utf_8_off ];
     my $cb = $filters{$textdomain};
 
     my $function = "Locale::${package}::gettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub dgettext($$) {
     my $cb = $filters{$_[0]} ||= [ \&turn_utf_8_off ];
 
     my $function = "Locale::${package}::dgettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub dcgettext($$$) {
     my $cb = $filters{$_[0]} ||= [ \&turn_utf_8_off ];
 
     my $function = "Locale::${package}::dcgettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub ngettext($$$) {
     my $textdomain = textdomain;
     $filters{$textdomain} ||= [ \&turn_utf_8_off ];
     my $cb = $filters{$textdomain};
 
     my $function = "Locale::${package}::ngettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub dngettext($$$$) {
     my $cb = $filters{$_[0]} ||= [ \&turn_utf_8_off ];
 
     my $function = "Locale::${package}::dngettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub dcngettext($$$$$) {
     my $cb = $filters{$_[0]} ||= [ \&turn_utf_8_off ];
 
     my $function = "Locale::${package}::dcngettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub pgettext($$) {
     my $textdomain = textdomain;
     $filters{$textdomain} ||= [ \&turn_utf_8_off ];
     my $cb = $filters{$textdomain};
 
     my $function = "Locale::${package}::pgettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub dpgettext($$$) {
     my $cb = $filters{$_[0]} ||= [ \&turn_utf_8_off ];
 
     my $function = "Locale::${package}::dpgettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub dcpgettext($$$$) {
     my $cb = $filters{$_[0]} ||= [ \&turn_utf_8_off ];
 
     my $function = "Locale::${package}::dcpgettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub npgettext($$$$) {
     my $cb = $filters{$_[0]} ||= [ \&turn_utf_8_off ];
 
     my $function = "Locale::${package}::npgettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub dnpgettext($$$$$) {
     my $cb = $filters{$_[0]} ||= [ \&turn_utf_8_off ];
 
     my $function = "Locale::${package}::dnpgettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub dcnpgettext($$$$$$) {
     my $cb = $filters{$_[0]} ||= [ \&turn_utf_8_off ];
 
     my $function = "Locale::${package}::dcnpgettext";
     
     no strict 'refs';
     $cb->[0] (&$function, $cb->[1]);
 }
 
 sub setlocale($;$) {
     my $function = "Locale::${package}::setlocale";
     
     no strict 'refs';
     &$function;
 }
 
 sub nl_putenv($) {
     my $function = "Locale::${package}::nl_putenv";
     
     no strict 'refs';
     &$function;
 }
 
 sub LC_NUMERIC {
     my $function = "Locale::${package}::LC_NUMERIC";
     
     no strict 'refs';
     &$function;
 }
 
 sub LC_CTYPE {
     my $function = "Locale::${package}::LC_CTYPE";
     
     no strict 'refs';
     &$function;
 }
 
 sub LC_TIME {
     my $function = "Locale::${package}::LC_TIME";
     
     no strict 'refs';
     &$function;
 }
 
 sub LC_COLLATE {
     my $function = "Locale::${package}::LC_COLLATE";
     
     no strict 'refs';
     &$function;
 }
 
 sub LC_MONETARY {
     my $function = "Locale::${package}::LC_MONETARY";
     
     no strict 'refs';
     &$function;
 }
 
 sub LC_MESSAGES {
     my $function = "Locale::${package}::LC_MESSAGES";
     
     no strict 'refs';
     &$function;
 }
 
 sub LC_ALL {
     my $function = "Locale::${package}::LC_ALL";
     
     no strict 'refs';
     &$function;
 }
 
 1;
 
 __END__
 
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/Recode.pm ###
 #! /bin/false
 
 
 
 
 
 
 package Locale::Recode;
 
 use strict;
 
 require Locale::Recode::_Conversions;
 
 my $loaded = {};
 my $has_encode;
 
 sub new
 {
     my $class = ref($_[0]) || $_[0];
     shift;
     my %args = @_;
 
     my $self = bless {}, $class;
 
     my ($from_codeset, $to_codeset) = @args{qw (from to)};
     
     unless ($from_codeset && $to_codeset) {
 		require Carp;
         Carp::croak (<<EOF);
 	Usage: $class->new (from => FROM_CODESET, to => TO_CODESET);
 EOF
     }
 
 	my $path = Locale::Recode::_Conversions->findPath ($from_codeset, 
 													   $to_codeset);
 	unless ($path) {
 		$self->{__error} = 'EINVAL';
 		return $self;
 	}
 
 	my @conversions = ();
 	foreach (@$path) {
 		my ($module, $from, $to) = @$_;
 		
 		unless ($loaded->{$module}) {
 			eval "require Locale::RecodeData::$module";
 			if ($@) {
 				$self->{__error} = $@;
 				return $self;
 			}
 			
 			$loaded->{$module} = 1;
 		}
 		
 		my $module_name = "Locale::RecodeData::$module";
 		my $method = 'new';
 		my $object = $module_name->$method (from => $from,
 											to => $to);
 		
 		push @conversions, $object;
 	}
 
 	$self->{__conversions} = \@conversions;
 		
     return $self;
 }
 
 sub resolveAlias
 {
 	my ($class, $alias) = @_;
 
 	return Locale::Recode::_Conversions->resolveAlias ($alias);
 }
 
 sub getSupported
 {
 	return [ Locale::Recode::_Conversions->listSupported ];
 }
 
 sub getCharsets
 {
 	my $self = shift;
 	my %all = map { $_ => 1 } @{&getSupported};
 
 	require Locale::Recode::_Aliases;
 
 	my $conversions = Locale::Recode::_Conversions->listSupported;
 	foreach my $charset (keys %{Locale::Recode::_Aliases::ALIASES()}) {
 		my $mime_name = $self->resolveAlias ($charset);
 		next unless exists $all{$mime_name};
 		$all{$charset} = 1;
 	}
 	
 	return [ keys %all ];
 }
 
 sub recode
 {
     my $self = $_[0];
 
     return if $self->{__error};
 
     return 1 unless defined $_[1];
 
     my $chain = $self->{__conversions};
     
     foreach my $module (@$chain) {
 		my $success = $module->_recode ($_[1]);
 		
 		unless ($success) {
 			$self->{__error} = $module->_getError;
 			return;
 		}
     }
 
     return 1;
 }
 
 sub getError
 {
     my $self = shift;
     my $error = $self->{__error} or return;
 
     if ('EINVAL' eq $error) {
 		return 'Invalid conversion';
     } else {
 		return $error;
     }
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/Recode/_Aliases.pm ###
 #! /bin/false
 
 
 
 
 
 
 package Locale::Recode::_Aliases;
 
 use constant ALIASES => {
 	'1047' => 'IBM1047',
     '437' => 'IBM437',
     '850' => 'IBM850',
     '851' => 'IBM851',
     '852' => 'IBM852',
     '855' => 'IBM855',
     '857' => 'IBM857',
     '860' => 'IBM860',
     '861' => 'IBM861',
     '862' => 'IBM862',
     '863' => 'IBM863',
     '865' => 'IBM865',
     '866' => 'IBM866',
     '869' => 'IBM869',
     '904' => 'IBM904',
     'ANSI_X3.4-1968' => 'US-ASCII',
     'ANSI_X3.4-1986' => 'US-ASCII',
     'ARABIC' => 'ISO-8859-6',
     'ARABIC7' => 'ASMO_449',
     'ASCII' => 'US-ASCII',
     'ASMO-708' => 'ISO-8859-6',
 	'ATARIST' => 'ATARI-ST',
 	'ATARIST-EURO' => 'ATARI-ST-EURO',
 	'BIG-5' => 'BIG5',
 	'BIG-FIVE' => 'BIG5',
 	'BIG5-ETEN' => 'BIG5',
 	'BIG5HKSCS' => 'BIG5-HKSCS',
 	'BIGFIVE' => 'BIG5',
     'CA' => 'CSA_Z243.4-1985-1',
     'CCSID00924' => 'IBM00924',
     'CCSID01140' => 'IBM01140',
     'CCSID01141' => 'IBM01141',
     'CCSID01142' => 'IBM01142',
     'CCSID01143' => 'IBM01143',
     'CCSID01144' => 'IBM01144',
     'CCSID01145' => 'IBM01145',
     'CCSID01146' => 'IBM01146',
     'CCSID01147' => 'IBM01147',
     'CCSID01148' => 'IBM01148',
     'CCSID01149' => 'IBM01149',
     'CHINESE' => 'GB_2312-80',
     'CN' => 'GB_1988-80',
 	'CN-BIG5' => 'BIG5',
     'CP-AR' => 'IBM868',
     'CP-GR' => 'IBM869',
 	'CP-HU' => 'CWI',
     'CP-IS' => 'IBM861',
     'CP00924' => 'IBM00924',
     'CP01140' => 'IBM01140',
     'CP01141' => 'IBM01141',
     'CP01142' => 'IBM01142',
     'CP01143' => 'IBM01143',
     'CP01144' => 'IBM01144',
     'CP01145' => 'IBM01145',
     'CP01146' => 'IBM01146',
     'CP01147' => 'IBM01147',
     'CP01148' => 'IBM01148',
     'CP01149' => 'IBM01149',
     'CP037' => 'IBM037',
     'CP038' => 'IBM038',
 	'CP1004' => 'IBM1004',
     'CP1026' => 'IBM1026',
 	'CP1047' => 'IBM1047',
 	'CP1250' => 'WINDOWS-1250',
 	'CP1251' => 'WINDOWS-1251',
 	'CP1252' => 'WINDOWS-1252',
 	'CP1253' => 'WINDOWS-1253',
 	'CP1254' => 'WINDOWS-1254',
 	'CP1255' => 'WINDOWS-1255',
 	'CP1256' => 'WINDOWS-1256',
 	'CP1257' => 'WINDOWS-1257',
 	'CP1258' => 'WINDOWS-1258',
     'CP154' => 'PTCP154',
     'CP273' => 'IBM273',
     'CP274' => 'IBM274',
     'CP275' => 'IBM275',
     'CP278' => 'IBM278',
     'CP280' => 'IBM280',
     'CP281' => 'IBM281',
     'CP284' => 'IBM284',
     'CP285' => 'IBM285',
     'CP290' => 'IBM290',
     'CP297' => 'IBM297',
     'CP367' => 'US-ASCII',
     'CP420' => 'IBM420',
     'CP423' => 'IBM423',
     'CP424' => 'IBM424',
     'CP437' => 'IBM437',
     'CP500' => 'IBM500',
     'CP775' => 'IBM775',
     'CP819' => 'ISO-8859-1',
     'CP850' => 'IBM850',
     'CP851' => 'IBM851',
     'CP852' => 'IBM852',
     'CP855' => 'IBM855',
     'CP857' => 'IBM857',
     'CP860' => 'IBM860',
     'CP861' => 'IBM861',
     'CP862' => 'IBM862',
     'CP863' => 'IBM863',
     'CP864' => 'IBM864',
     'CP865' => 'IBM865',
     'CP866' => 'IBM866',
     'CP868' => 'IBM868',
     'CP869' => 'IBM869',
     'CP870' => 'IBM870',
     'CP871' => 'IBM871',
 	'CP874' => 'IBM874',
 	'CP875' => 'IBM875',
     'CP880' => 'IBM880',
     'CP891' => 'IBM891',
     'CP903' => 'IBM903',
     'CP904' => 'IBM904',
     'CP905' => 'IBM905',
     'CP918' => 'IBM918',
     'CP936' => 'GBK',
     'CSA7-1' => 'CSA_Z243.4-1985-1',
     'CSA7-2' => 'CSA_Z243.4-1985-2',
     'CSADOBESTANDARDENCODING' => 'ADOBE-STANDARD-ENCODING',
     'CSASCII' => 'US-ASCII',
     'CSA_T500-1983' => 'ANSI_X3.110-1983',
     'CSBIG5' => 'BIG5',
     'CSBOCU-1' => 'BOCU-1',
     'CSCESU-8' => 'CESU-8',
     'CSDECMCS' => 'DEC-MCS',
     'CSDKUS' => 'DK-US',
     'CSEBCDICATDEA' => 'EBCDIC-AT-DE-A',
     'CSEBCDICCAFR' => 'EBCDIC-CA-FR',
     'CSEBCDICDKNO' => 'EBCDIC-DK-NO',
     'CSEBCDICDKNOA' => 'EBCDIC-DK-NO-A',
     'CSEBCDICES' => 'EBCDIC-ES',
     'CSEBCDICESA' => 'EBCDIC-ES-A',
     'CSEBCDICESS' => 'EBCDIC-ES-S',
     'CSEBCDICFISE' => 'EBCDIC-FI-SE',
     'CSEBCDICFISEA' => 'EBCDIC-FI-SE-A',
     'CSEBCDICFR' => 'EBCDIC-FR',
     'CSEBCDICIT' => 'EBCDIC-IT',
     'CSEBCDICPT' => 'EBCDIC-PT',
     'CSEBCDICUK' => 'EBCDIC-UK',
     'CSEBCDICUS' => 'EBCDIC-US',
     'CSEUCFIXWIDJAPANESE' => 'EXTENDED_UNIX_CODE_FIXED_WIDTH_FOR_JAPANESE',
     'CSEUCKR' => 'EUC-KR',
     'CSEUCPKDFMTJAPANESE' => 'EUC-JP',
     'CSEUCTW' => 'EUC-TW',
     'CSGB2312' => 'GB2312',
     'CSHALFWIDTHKATAKANA' => 'JIS_X0201',
     'CSHPDESKTOP' => 'HP-DESKTOP',
     'CSHPLEGAL' => 'HP-LEGAL',
     'CSHPMATH8' => 'HP-MATH8',
     'CSHPPIFONT' => 'HP-PI-FONT',
     'CSHPPSMATH' => 'ADOBE-SYMBOL-ENCODING',
     'CSHPROMAN8' => 'HP-ROMAN8',
     'CSIBBM904' => 'IBM904',
     'CSIBM037' => 'IBM037',
     'CSIBM038' => 'IBM038',
     'CSIBM1026' => 'IBM1026',
     'CSIBM273' => 'IBM273',
     'CSIBM274' => 'IBM274',
     'CSIBM275' => 'IBM275',
     'CSIBM277' => 'IBM277',
     'CSIBM278' => 'IBM278',
     'CSIBM280' => 'IBM280',
     'CSIBM281' => 'IBM281',
     'CSIBM284' => 'IBM284',
     'CSIBM285' => 'IBM285',
     'CSIBM290' => 'IBM290',
     'CSIBM297' => 'IBM297',
     'CSIBM420' => 'IBM420',
     'CSIBM423' => 'IBM423',
     'CSIBM424' => 'IBM424',
     'CSIBM500' => 'IBM500',
     'CSIBM851' => 'IBM851',
     'CSIBM855' => 'IBM855',
     'CSIBM857' => 'IBM857',
     'CSIBM860' => 'IBM860',
     'CSIBM861' => 'IBM861',
     'CSIBM863' => 'IBM863',
     'CSIBM864' => 'IBM864',
     'CSIBM865' => 'IBM865',
     'CSIBM866' => 'IBM866',
     'CSIBM868' => 'IBM868',
     'CSIBM869' => 'IBM869',
     'CSIBM870' => 'IBM870',
     'CSIBM871' => 'IBM871',
     'CSIBM880' => 'IBM880',
     'CSIBM891' => 'IBM891',
     'CSIBM903' => 'IBM903',
     'CSIBM905' => 'IBM905',
     'CSIBM918' => 'IBM918',
     'CSIBMEBCDICATDE' => 'EBCDIC-AT-DE',
     'CSIBMSYMBOLS' => 'IBM-SYMBOLS',
     'CSIBMTHAI' => 'IBM-THAI',
     'CSINVARIANT' => 'INVARIANT',
     'CSISO102T617BIT' => 'T.61-7BIT',
     'CSISO10367BOX' => 'ISO_10367-BOX',
     'CSISO10646UTF1' => 'ISO-10646-UTF-1',
     'CSISO10SWEDISH' => 'SEN_850200_B',
     'CSISO111ECMACYRILLIC' => 'ECMA-CYRILLIC',
     'CSISO11SWEDISHFORNAMES' => 'SEN_850200_C',
     'CSISO121CANADIAN1' => 'CSA_Z243.4-1985-1',
     'CSISO122CANADIAN2' => 'CSA_Z243.4-1985-2',
     'CSISO123CSAZ24341985GR' => 'CSA_Z243.4-1985-GR',
     'CSISO128T101G2' => 'T.101-G2',
     'CSISO139CSN369103' => 'CSN_369103',
     'CSISO13JISC6220JP' => 'JIS_C6220-1969-JP',
     'CSISO141JUSIB1002' => 'JUS_I.B1.002',
     'CSISO143IECP271' => 'IEC_P27-1',
     'CSISO146SERBIAN' => 'JUS_I.B1.003-SERB',
     'CSISO147MACEDONIAN' => 'JUS_I.B1.003-MAC',
     'CSISO14JISC6220RO' => 'JIS_C6220-1969-RO',
     'CSISO150' => 'GREEK-CCITT',
     'CSISO150GREEKCCITT' => 'GREEK-CCITT',
     'CSISO151CUBA' => 'NC_NC00-10:81',
     'CSISO153GOST1976874' => 'GOST_19768-74',
     'CSISO158LAP' => 'LATIN-LAP',
     'CSISO159JISX02121990' => 'JIS_X0212-1990',
     'CSISO15ITALIAN' => 'IT',
     'CSISO16PORTUGUESE' => 'PT',
     'CSISO17SPANISH' => 'ES',
     'CSISO18GREEK7OLD' => 'GREEK7-OLD',
     'CSISO19LATINGREEK' => 'LATIN-GREEK',
     'CSISO2022JP' => 'ISO-2022-JP',
     'CSISO2022JP2' => 'ISO-2022-JP-2',
     'CSISO2022KR' => 'ISO-2022-KR',
     'CSISO2033' => 'ISO_2033-1983',
     'CSISO21GERMAN' => 'DIN_66003',
     'CSISO25FRENCH' => 'NF_Z_62-010_(1973)',
     'CSISO27LATINGREEK1' => 'LATIN-GREEK-1',
     'CSISO2INTLREFVERSION' => 'ISO_646.IRV:1983',
     'CSISO42JISC62261978' => 'JIS_C6226-1978',
     'CSISO47BSVIEWDATA' => 'BS_VIEWDATA',
     'CSISO49INIS' => 'INIS',
     'CSISO4UNITEDKINGDOM' => 'BS_4730',
     'CSISO50INIS8' => 'INIS-8',
     'CSISO51INISCYRILLIC' => 'INIS-CYRILLIC',
     'CSISO5427CYRILLIC' => 'ISO_5427',
     'CSISO5428GREEK' => 'ISO_5428:1980',
     'CSISO57GB1988' => 'GB_1988-80',
     'CSISO58GB231280' => 'GB_2312-80',
     'CSISO60DANISHNORWEGIAN' => 'NS_4551-1',
     'CSISO60NORWEGIAN1' => 'NS_4551-1',
     'CSISO61NORWEGIAN2' => 'NS_4551-2',
     'CSISO646BASIC1983' => 'ISO_646.BASIC:1983',
     'CSISO646DANISH' => 'DS_2089',
     'CSISO6937ADD' => 'ISO_6937-2-25',
     'CSISO69FRENCH' => 'NF_Z_62-010',
     'CSISO70VIDEOTEXSUPP1' => 'VIDEOTEX-SUPPL',
     'CSISO84PORTUGUESE2' => 'PT2',
     'CSISO85SPANISH2' => 'ES2',
     'CSISO86HUNGARIAN' => 'MSZ_7795.3',
     'CSISO87JISX0208' => 'JIS_C6226-1983',
     'CSISO88596E' => 'ISO-8859-6-E',
     'CSISO88596I' => 'ISO-8859-6-I',
     'CSISO88598E' => 'ISO-8859-8-E',
     'CSISO88598I' => 'ISO-8859-8-I',
     'CSISO8859SUPP' => 'ISO_8859-SUPP',
     'CSISO88GREEK7' => 'GREEK7',
     'CSISO89ASMO449' => 'ASMO_449',
     'CSISO90' => 'ISO-IR-90',
     'CSISO91JISC62291984A' => 'JIS_C6229-1984-A',
     'CSISO92JISC62991984B' => 'JIS_C6229-1984-B',
     'CSISO93JIS62291984BADD' => 'JIS_C6229-1984-B-ADD',
     'CSISO94JIS62291984HAND' => 'JIS_C6229-1984-HAND',
     'CSISO95JIS62291984HANDADD' => 'JIS_C6229-1984-HAND-ADD',
     'CSISO96JISC62291984KANA' => 'JIS_C6229-1984-KANA',
     'CSISO99NAPLPS' => 'ANSI_X3.110-1983',
     'CSISOLATIN1' => 'ISO-8859-1',
     'CSISOLATIN2' => 'ISO-8859-2',
     'CSISOLATIN3' => 'ISO-8859-3',
     'CSISOLATIN4' => 'ISO-8859-4',
     'CSISOLATIN5' => 'ISO-8859-9',
     'CSISOLATIN6' => 'ISO-8859-10',
     'CSISOLATINARABIC' => 'ISO-8859-6',
     'CSISOLATINCYRILLIC' => 'ISO-8859-5',
     'CSISOLATINGREEK' => 'ISO-8859-7',
     'CSISOLATINHEBREW' => 'ISO-8859-8',
     'CSISOTEXTCOMM' => 'ISO_6937-2-ADD',
     'CSJISENCODING' => 'JIS_ENCODING',
     'CSKOI8R' => 'KOI8-R',
     'CSKSC56011987' => 'KS_C_5601-1987',
     'CSKSC5636' => 'KSC5636',
     'CSMACINTOSH' => 'MACINTOSH',
     'CSMICROSOFTPUBLISHING' => 'MICROSOFT-PUBLISHING',
     'CSMNEM' => 'MNEM',
     'CSMNEMONIC' => 'MNEMONIC',
     'CSNATSDANO' => 'NATS-DANO',
     'CSNATSDANOADD' => 'NATS-DANO-ADD',
     'CSNATSSEFI' => 'NATS-SEFI',
     'CSNATSSEFIADD' => 'NATS-SEFI-ADD',
     'CSPC775BALTIC' => 'IBM775',
     'CSPC850MULTILINGUAL' => 'IBM850',
     'CSPC862LATINHEBREW' => 'IBM862',
     'CSPC8CODEPAGE437' => 'IBM437',
     'CSPC8DANISHNORWEGIAN' => 'PC8-DANISH-NORWEGIAN',
     'CSPC8TURKISH' => 'PC8-TURKISH',
     'CSPCP852' => 'IBM852',
     'CSPTCP154' => 'PTCP154',
     'CSSHIFTJIS' => 'SHIFT_JIS',
     'CSUCS4' => 'ISO-10646-UCS-4',
     'CSUNICODE' => 'ISO-10646-UCS-2',
     'CSUNICODE11' => 'UNICODE-1-1',
     'CSUNICODE11UTF7' => 'UNICODE-1-1-UTF-7',
     'CSUNICODEASCII' => 'ISO-10646-UCS-BASIC',
     'CSUNICODEIBM1264' => 'ISO-UNICODE-IBM-1264',
     'CSUNICODEIBM1265' => 'ISO-UNICODE-IBM-1265',
     'CSUNICODEIBM1268' => 'ISO-UNICODE-IBM-1268',
     'CSUNICODEIBM1276' => 'ISO-UNICODE-IBM-1276',
     'CSUNICODELATIN1' => 'ISO-10646-UNICODE-LATIN1',
     'CSUNKNOWN8BIT' => 'UNKNOWN-8BIT',
     'CSUSDK' => 'US-DK',
     'CSVENTURAINTERNATIONAL' => 'VENTURA-INTERNATIONAL',
     'CSVENTURAMATH' => 'VENTURA-MATH',
     'CSVENTURAUS' => 'VENTURA-US',
     'CSVIQR' => 'VIQR',
     'CSVISCII' => 'VISCII',
     'CSWINDOWS30LATIN1' => 'ISO-8859-1-WINDOWS-3.0-LATIN-1',
     'CSWINDOWS31J' => 'WINDOWS-31J',
     'CSWINDOWS31LATIN1' => 'ISO-8859-1-WINDOWS-3.1-LATIN-1',
     'CSWINDOWS31LATIN2' => 'ISO-8859-2-WINDOWS-LATIN-2',
     'CSWINDOWS31LATIN5' => 'ISO-8859-9-WINDOWS-LATIN-5',
     'CUBA' => 'NC_NC00-10:81',
 	'CWI-2' => 'CWI',
     'CYRILLIC' => 'ISO-8859-5',
     'CYRILLIC-ASIAN' => 'PTCP154',
     'DE' => 'DIN_66003',
     'DEC' => 'DEC-MCS',
     'DK' => 'DS_2089',
     'DS2089' => 'DS_2089',
     'E13B' => 'ISO_2033-1983',
     'EBCDIC-BE' => 'IBM274',
     'EBCDIC-BR' => 'IBM275',
     'EBCDIC-CP-AR1' => 'IBM420',
     'EBCDIC-CP-AR2' => 'IBM918',
     'EBCDIC-CP-BE' => 'IBM500',
     'EBCDIC-CP-CA' => 'IBM037',
     'EBCDIC-CP-CH' => 'IBM500',
     'EBCDIC-CP-DK' => 'IBM277',
     'EBCDIC-CP-ES' => 'IBM284',
     'EBCDIC-CP-FI' => 'IBM278',
     'EBCDIC-CP-FR' => 'IBM297',
     'EBCDIC-CP-GB' => 'IBM285',
     'EBCDIC-CP-GR' => 'IBM423',
     'EBCDIC-CP-HE' => 'IBM424',
     'EBCDIC-CP-IS' => 'IBM871',
     'EBCDIC-CP-IT' => 'IBM280',
     'EBCDIC-CP-NL' => 'IBM037',
     'EBCDIC-CP-NO' => 'IBM277',
     'EBCDIC-CP-ROECE' => 'IBM870',
     'EBCDIC-CP-SE' => 'IBM278',
     'EBCDIC-CP-TR' => 'IBM905',
     'EBCDIC-CP-US' => 'IBM037',
     'EBCDIC-CP-WT' => 'IBM037',
     'EBCDIC-CP-YU' => 'IBM870',
     'EBCDIC-CYRILLIC' => 'IBM880',
     'EBCDIC-DE-273+EURO' => 'IBM01141',
     'EBCDIC-DK-277+EURO' => 'IBM01142',
     'EBCDIC-ES-284+EURO' => 'IBM01145',
     'EBCDIC-FI-278+EURO' => 'IBM01143',
     'EBCDIC-FR-297+EURO' => 'IBM01147',
     'EBCDIC-GB-285+EURO' => 'IBM01146',
 	'EBCDIC-GREEK' => 'IBM875',
     'EBCDIC-INT' => 'IBM038',
 	'EBCDIC-INT1' => 'IBM256',
     'EBCDIC-INTERNATIONAL-500+EURO' => 'IBM01148',
     'EBCDIC-IS-871+EURO' => 'IBM01149',
     'EBCDIC-IT-280+EURO' => 'IBM01144',
     'EBCDIC-JP-E' => 'IBM281',
     'EBCDIC-JP-KANA' => 'IBM290',
     'EBCDIC-LATIN9--EURO' => 'IBM00924',
     'EBCDIC-NO-277+EURO' => 'IBM01142',
     'EBCDIC-SE-278+EURO' => 'IBM01143',
     'EBCDIC-US-37+EURO' => 'IBM01140',
     'ECMA-114' => 'ISO-8859-6',
     'ECMA-118' => 'ISO-8859-7',
     'ELOT_928' => 'ISO-8859-7',
 	'EUC-CN' => 'CN-GB',
 	'EUCCN' => 'CN-GB',
 	'EUCJP' => 'EUC-JP',
 	'EUCKR' => 'EUC-KR',
 	'EUCTW' => 'EUC-TW',
     'EXTENDED_UNIX_CODE_PACKED_FORMAT_FOR_JAPANESE' => 'EUC-JP',
     'FI' => 'SEN_850200_B',
     'FR' => 'NF_Z_62-010',
 	'FRISS' => 'EBCDIC-IS-FRISS',
     'GB' => 'BS_4730',
     'GB2312' => 'CN-GB',
 	'GBK' => 'CP936',
     'GREEK' => 'ISO-8859-7',
     'GREEK8' => 'ISO-8859-7',
     'HEBREW' => 'ISO-8859-8',
     'HU' => 'MSZ_7795.3',
 	'HZ-GB-2312' => 'HZ',
     'IBM367' => 'US-ASCII',
 	'IBM775' => 'CP775',
     'IBM819' => 'ISO-8859-1',
     'IRV' => 'ISO_646.IRV:1983',
     'ISO-10646' => 'ISO-10646-UNICODE-LATIN1',
     'ISO-CELTIC' => 'ISO-8859-14',
     'ISO-IR-10' => 'SEN_850200_B',
     'ISO-IR-100' => 'ISO-8859-1',
     'ISO-IR-101' => 'ISO-8859-2',
     'ISO-IR-102' => 'T.61-7BIT',
     'ISO-IR-109' => 'ISO-8859-3',
     'ISO-IR-11' => 'SEN_850200_C',
     'ISO-IR-110' => 'ISO-8859-4',
     'ISO-IR-111' => 'ECMA-CYRILLIC',
     'ISO-IR-121' => 'CSA_Z243.4-1985-1',
     'ISO-IR-122' => 'CSA_Z243.4-1985-2',
     'ISO-IR-123' => 'CSA_Z243.4-1985-GR',
     'ISO-IR-126' => 'ISO-8859-7',
     'ISO-IR-127' => 'ISO-8859-6',
     'ISO-IR-128' => 'T.101-G2',
     'ISO-IR-13' => 'JIS_C6220-1969-JP',
     'ISO-IR-138' => 'ISO-8859-8',
     'ISO-IR-139' => 'CSN_369103',
     'ISO-IR-14' => 'JIS_C6220-1969-RO',
     'ISO-IR-141' => 'JUS_I.B1.002',
     'ISO-IR-142' => 'ISO_6937-2-ADD',
     'ISO-IR-143' => 'IEC_P27-1',
     'ISO-IR-144' => 'ISO-8859-5',
     'ISO-IR-146' => 'JUS_I.B1.003-SERB',
     'ISO-IR-147' => 'JUS_I.B1.003-MAC',
     'ISO-IR-148' => 'ISO-8859-9',
     'ISO-IR-149' => 'KS_C_5601-1987',
     'ISO-IR-15' => 'IT',
     'ISO-IR-150' => 'GREEK-CCITT',
     'ISO-IR-151' => 'NC_NC00-10:81',
     'ISO-IR-152' => 'ISO_6937-2-25',
     'ISO-IR-153' => 'GOST_19768-74',
     'ISO-IR-154' => 'ISO_8859-SUPP',
     'ISO-IR-155' => 'ISO_10367-BOX',
     'ISO-IR-157' => 'ISO-8859-10',
     'ISO-IR-158' => 'LATIN-LAP',
     'ISO-IR-159' => 'JIS_X0212-1990',
     'ISO-IR-16' => 'PT',
 	'ISO-IR-166' => 'TIS-620',
     'ISO-IR-17' => 'ES',
 	'ISO-IR-179' => 'ISO-8859-13',
     'ISO-IR-18' => 'GREEK7-OLD',
     'ISO-IR-19' => 'LATIN-GREEK',
     'ISO-IR-199' => 'ISO-8859-14',
     'ISO-IR-2' => 'ISO_646.IRV:1983',
     'ISO-IR-203' => 'ISO-8859-15',
     'ISO-IR-21' => 'DIN_66003',
     'ISO-IR-226' => 'ISO-8859-16',
     'ISO-IR-25' => 'NF_Z_62-010_(1973)',
     'ISO-IR-27' => 'LATIN-GREEK-1',
     'ISO-IR-37' => 'ISO_5427',
     'ISO-IR-4' => 'BS_4730',
     'ISO-IR-42' => 'JIS_C6226-1978',
     'ISO-IR-47' => 'BS_VIEWDATA',
     'ISO-IR-49' => 'INIS',
     'ISO-IR-50' => 'INIS-8',
     'ISO-IR-51' => 'INIS-CYRILLIC',
     'ISO-IR-54' => 'ISO_5427-EXT',
     'ISO-IR-55' => 'ISO_5428',
     'ISO-IR-57' => 'GB_1988-80',
     'ISO-IR-58' => 'GB_2312-80',
     'ISO-IR-6' => 'US-ASCII',
     'ISO-IR-60' => 'NS_4551-1',
     'ISO-IR-61' => 'NS_4551-2',
     'ISO-IR-69' => 'NF_Z_62-010',
     'ISO-IR-70' => 'VIDEOTEX-SUPPL',
     'ISO-IR-79' => 'ISO-8859-13',
     'ISO-IR-8-1' => 'NATS-SEFI',
     'ISO-IR-8-2' => 'NATS-SEFI-ADD',
     'ISO-IR-84' => 'PT2',
     'ISO-IR-85' => 'ES2',
     'ISO-IR-86' => 'MSZ_7795.3',
     'ISO-IR-87' => 'JIS_C6226-1983',
     'ISO-IR-88' => 'GREEK7',
     'ISO-IR-89' => 'ASMO_449',
     'ISO-IR-9-1' => 'NATS-DANO',
     'ISO-IR-9-2' => 'NATS-DANO-ADD',
     'ISO-IR-91' => 'JIS_C6229-1984-A',
     'ISO-IR-92' => 'JIS_C6229-1984-B',
     'ISO-IR-93' => 'JIS_C6229-1984-B-ADD',
     'ISO-IR-94' => 'JIS_C6229-1984-HAND',
     'ISO-IR-95' => 'JIS_C6229-1984-HAND-ADD',
     'ISO-IR-96' => 'JIS_C6229-1984-KANA',
     'ISO-IR-98' => 'ISO_2033-1983',
     'ISO-IR-99' => 'ANSI_X3.110-1983',
     'ISO5427CYRILLIC1981' => 'ISO_5427:1981',
     'ISO646-CA' => 'CSA_Z243.4-1985-1',
     'ISO646-CA2' => 'CSA_Z243.4-1985-2',
     'ISO646-CN' => 'GB_1988-80',
     'ISO646-CU' => 'NC_NC00-10:81',
     'ISO646-DE' => 'DIN_66003',
     'ISO646-DK' => 'DS_2089',
     'ISO646-ES' => 'ES',
     'ISO646-ES2' => 'ES2',
     'ISO646-FI' => 'SEN_850200_B',
     'ISO646-FR' => 'NF_Z_62-010',
     'ISO646-FR1' => 'NF_Z_62-010_(1973)',
     'ISO646-GB' => 'BS_4730',
     'ISO646-HU' => 'MSZ_7795.3',
     'ISO646-IT' => 'IT',
     'ISO646-JP' => 'JIS_C6220-1969-RO',
     'ISO646-JP-OCR-B' => 'JIS_C6229-1984-B',
     'ISO646-KR' => 'KSC5636',
     'ISO646-NO' => 'NS_4551-1',
     'ISO646-NO2' => 'NS_4551-2',
     'ISO646-PT' => 'PT',
     'ISO646-PT2' => 'PT2',
     'ISO646-SE' => 'SEN_850200_B',
     'ISO646-SE2' => 'SEN_850200_C',
     'ISO646-US' => 'US-ASCII',
     'ISO646-YU' => 'JUS_I.B1.002',
 	'ISO_5427:1981' => 'ISO_5427-EXT',
     'ISO_5428:1980' => 'ISO_5428',
     'ISO_646.IRV:1991' => 'US-ASCII',
     'ISO_8859-1' => 'ISO-8859-1',
     'ISO_8859-1:1987' => 'ISO-8859-1',
     'ISO_8859-10' => 'ISO-8859-10',
     'ISO_8859-10:1992' => 'ISO-8859-10',
     'ISO_8859-13' => 'ISO-8859-13',
     'ISO_8859-14' => 'ISO-8859-14',
     'ISO_8859-14:1998' => 'ISO-8859-14',
     'ISO_8859-15' => 'ISO-8859-15',
     'ISO_8859-15:1998' => 'ISO-8859-15',
     'ISO_8859-16' => 'ISO-8859-16',
     'ISO_8859-16:2001' => 'ISO-8859-16',
     'ISO_8859-1:1987' => 'ISO-8859-1',
     'ISO_8859-2' => 'ISO-8859-2',
     'ISO_8859-2:1987' => 'ISO-8859-2',
     'ISO_8859-3' => 'ISO-8859-3',
     'ISO_8859-3:1988' => 'ISO-8859-3',
     'ISO_8859-4' => 'ISO-8859-4',
     'ISO_8859-4:1988' => 'ISO-8859-4',
     'ISO_8859-5' => 'ISO-8859-5',
     'ISO_8859-5:1988' => 'ISO-8859-5',
     'ISO_8859-6' => 'ISO-8859-6',
     'ISO_8859-6-E' => 'ISO-8859-6-E',
     'ISO_8859-6-I' => 'ISO-8859-6-I',
     'ISO_8859-6:1987' => 'ISO-8859-6',
     'ISO_8859-7' => 'ISO-8859-7',
     'ISO_8859-7:1987' => 'ISO-8859-7',
     'ISO_8859-8' => 'ISO-8859-8',
     'ISO_8859-8-E' => 'ISO-8859-8-E',
     'ISO_8859-8-I' => 'ISO-8859-8-I',
     'ISO_8859-8:1988' => 'ISO-8859-8',
     'ISO_8859-9' => 'ISO-8859-9',
     'ISO_8859-9:1989' => 'ISO-8859-9',
     'ISO_9036' => 'ASMO_449',
     'JIS_C6220-1969' => 'JIS_C6220-1969-JP',
     'JIS_X0208-1983' => 'JIS_C6226-1983',
     'JP' => 'JIS_C6220-1969-RO',
     'JP-OCR-A' => 'JIS_C6229-1984-A',
     'JP-OCR-B' => 'JIS_C6229-1984-B',
     'JP-OCR-B-ADD' => 'JIS_C6229-1984-B-ADD',
     'JP-OCR-HAND' => 'JIS_C6229-1984-HAND',
     'JP-OCR-HAND-ADD' => 'JIS_C6229-1984-HAND-ADD',
     'JS' => 'JUS_I.B1.002',
     'KATAKANA' => 'JIS_C6220-1969-JP',
     'KOREAN' => 'KS_C_5601-1987',
     'KSC_5601' => 'KS_C_5601-1987',
     'KS_C_5601-1989' => 'KS_C_5601-1987',
     'L1' => 'ISO-8859-1',
     'L10' => 'ISO-8859-16',
     'L2' => 'ISO-8859-2',
     'L3' => 'ISO-8859-3',
     'L4' => 'ISO-8859-4',
     'L5' => 'ISO-8859-9',
     'L6' => 'ISO-8859-10',
 	'L7' => 'ISO-8859-13',
     'L8' => 'ISO-8859-14',
     'LAP' => 'LATIN-LAP',
     'LATIN-9' => 'ISO-8859-15',
     'LATIN1' => 'ISO-8859-1',
     'LATIN1-2-5' => 'ISO_8859-SUPP',
     'LATIN10' => 'ISO-8859-16',
     'LATIN2' => 'ISO-8859-2',
     'LATIN3' => 'ISO-8859-3',
     'LATIN4' => 'ISO-8859-4',
     'LATIN5' => 'ISO-8859-9',
     'LATIN6' => 'ISO-8859-10',
 	'LATIN7' => 'ISO-8859-13',
     'LATIN8' => 'ISO-8859-14',
     'MAC' => 'MACINTOSH',
 	'MAC-ARABIC' => 'MACARABIC',
 	'MAC-CENTRALEUROPE' => 'MACCENTRALEUROPE',
 	'MAC-CROATIAN' => 'MACCROATIAN',
 	'MAC-CYRILLIC' => 'MACCYRILLIC',
 	'MAC-GREEK' => 'MACGREEK',
 	'MAC-HEBREW' => 'MACHEBREW',
 	'MAC-ICELAND' => 'MACICELAND',
 	'MAC-ROMANIA' => 'MACROMANIA',
 	'MAC-THAI' => 'MACTHAI',
 	'MAC-TURKISH' => 'MACTURKISH',
 	'MAC-UKRAINE' => 'MACUKRAINE',
     'MACEDONIAN' => 'JUS_I.B1.003-MAC',
 	'MS-ARAB' => 'WINDOWS-1256',
 	'MS-ANSI' => 'WINDOWS-1252',
 	'MS-EE' => 'WINDOWS-1250',
 	'MS-CYRL' => 'WINDOWS-1251',
 	'MS-GREEK' => 'WINDOWS-1253',
 	'MS-HEBR' => 'WINDOWS-1255',
 	'MS-TURK' => 'WINDOWS-1254',
     'MS936' => 'GBK',
     'MS_KANJI' => 'SHIFT_JIS',
     'NAPLPS' => 'ANSI_X3.110-1983',
     'NO' => 'NS_4551-1',
     'NO2' => 'NS_4551-2',
 	'OS2LATIN1' => 'IBM1004',
     'PT154' => 'PTCP154',
     'R8' => 'HP-ROMAN8',
     'REF' => 'ISO_646.BASIC:1983',
     'ROMAN8' => 'HP-ROMAN8',
     'SE' => 'SEN_850200_B',
     'SE2' => 'SEN_850200_C',
     'SERBIAN' => 'JUS_I.B1.003-SERB',
     'ST_SEV_358-88' => 'GOST_19768-74',
     'T.61' => 'T.61-8BIT',
 	'TIS620' => 'TIS-620',
 	'TIS620-0' => 'TIS-620',
 	'TIS620.2529-1' => 'TIS-620',
 	'TIS620.2533-0' => 'TIS-620',
 	'TIS620.2533-1' => 'TIS-620',
 	'UHC' => 'CP949',
     'UK' => 'BS_4730',
     'US' => 'US-ASCII',
 	'VISCII1.1-1' => 'VISCII',
 	'WINBALTRIM' => 'WINDOWS-1257',
 	'WINDOWS-874' => 'CP874',
     'WINDOWS-936' => 'GBK',
 	'WINDOWS-SAMI2' => 'WIN-SAMI-2',
 	'WS2' => 'WIN-SAMI-2',
     'X0201' => 'JIS_X0201',
     'X0201-7' => 'JIS_C6220-1969-JP',
     'X0208' => 'JIS_C6226-1983',
     'X0212' => 'JIS_X0212-1990',
     'YU' => 'JUS_I.B1.002',
 	'X-ATARI-ST' => 'ATARI-ST',
 	'X-ATARIST' => 'ATARI-ST',
 	'X-ATARI-ST-EURO' => 'ATARI-ST-EURO',
 	'X-ATARIST-EURO' => 'ATARI-ST-EURO',
 	'X-MAC-ARABIC' => 'MACARABIC',
 	'X-MAC-CENTRALEUROPE' => 'MACCENTRALEUROPE',
 	'X-MAC-CROATIAN' => 'MACCROATIAN',
 	'X-MAC-CYRILLIC' => 'MACCYRILLIC',
 	'X-MAC-GREEK' => 'MACGREEK',
 	'X-MAC-HEBREW' => 'MACHEBREW',
 	'X-MAC-ICELAND' => 'MACICELAND',
 	'X-MAC-ROMANIA' => 'MACROMANIA',
 	'X-MAC-THAI' => 'MACTHAI',
 	'X-MAC-TURKISH' => 'MACTURKISH',
 	'X-MAC-UKRAINE' => 'MACUKRAINE',
 	'X-MACARABIC' => 'MACARABIC',
 	'X-MACCENTRALEUROPE' => 'MACCENTRALEUROPE',
 	'X-MACCROATIAN' => 'MACCROATIAN',
 	'X-MACCYRILLIC' => 'MACCYRILLIC',
 	'X-MACGREEK' => 'MACGREEK',
 	'X-MACHEBREW' => 'MACHEBREW',
 	'X-MACICELAND' => 'MACICELAND',
 	'X-MACROMANIA' => 'MACROMANIA',
 	'X-MACTHAI' => 'MACTHAI',
 	'X-MACTURKISH' => 'MACTURKISH',
 	'X-MACUKRAINE' => 'MACUKRAINE',
 };
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/Recode/_Conversions.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::Recode::_Conversions;
 
 use strict;
 use integer;
 
 use vars qw ($conversions $optional_conversions);
 
 $conversions = {
 	'ASMO_449' => 'ASMO_449',
 	'ATARI-ST-EURO' => 'ATARI_ST_EURO',
 	'ATARI-ST' => 'ATARI_ST',
 	'CP10007' => 'CP10007',
 	'CSN_369103' => 'CSN_369103',
 	'CWI' => 'CWI',
 	'DEC-MCS' => 'DEC_MCS',
 	'EBCDIC-AT-DE-A' => 'EBCDIC_AT_DE_A',
 	'EBCDIC-AT-DE' => 'EBCDIC_AT_DE',
 	'EBCDIC-CA-FR' => 'EBCDIC_CA_FR',
 	'EBCDIC-DK-NO-A' => 'EBCDIC_DK_NO_A',
 	'EBCDIC-DK-NO' => 'EBCDIC_DK_NO',
 	'EBCDIC-ES-A' => 'EBCDIC_ES_A',
 	'EBCDIC-ES-S' => 'EBCDIC_ES_S',
 	'EBCDIC-ES' => 'EBCDIC_ES',
 	'EBCDIC-FI-SE-A' => 'EBCDIC_FI_SE_A',
 	'EBCDIC-FI-SE' => 'EBCDIC_FI_SE',
 	'EBCDIC-FR' => 'EBCDIC_FR',
 	'EBCDIC-IS-FRISS' => 'EBCDIC_IS_FRISS',
 	'EBCDIC-IT' => 'EBCDIC_IT',
 	'EBCDIC-PT' => 'EBCDIC_PT',
 	'EBCDIC-UK' => 'EBCDIC_UK',
 	'EBCDIC-US' => 'EBCDIC_US',
 	'ECMA-CYRILLIC' => 'ECMA_CYRILLIC',
 	'GEORGIAN-ACADEMY' => 'GEORGIAN_ACADEMY',
 	'GEORGIAN-PS' => 'GEORGIAN_PS',
 	'GOST_19768-74' => 'GOST_19768_74',
 	'GREEK-CCITT' => 'GREEK_CCITT',
 	'GREEK7-OLD' => 'GREEK7_OLD',
 	'GREEK7' => 'GREEK7',
 	'HP-ROMAN8' => 'HP_ROMAN8',
 	'IBM037' => 'IBM037',
 	'IBM038' => 'IBM038',
 	'IBM1004' => 'IBM1004',
 	'IBM1026' => 'IBM1026',
 	'IBM1047' => 'IBM1047',
 	'IBM256' => 'IBM256',
 	'IBM273' => 'IBM273',
 	'IBM274' => 'IBM274',
 	'IBM275' => 'IBM275',
 	'IBM277' => 'IBM277',
 	'IBM278' => 'IBM278',
 	'IBM280' => 'IBM280',
 	'IBM281' => 'IBM281',
 	'IBM284' => 'IBM284',
 	'IBM285' => 'IBM285',
 	'IBM290' => 'IBM290',
 	'IBM297' => 'IBM297',
 	'IBM420' => 'IBM420',
 	'IBM423' => 'IBM423',
 	'IBM424' => 'IBM424',
 	'IBM437' => 'IBM437',
 	'IBM500' => 'IBM500',
 	'IBM850' => 'IBM850',
 	'IBM851' => 'IBM851',
 	'IBM852' => 'IBM852',
 	'IBM855' => 'IBM855',
 	'IBM857' => 'IBM857',
 	'IBM860' => 'IBM860',
 	'IBM861' => 'IBM861',
 	'IBM862' => 'IBM862',
 	'IBM863' => 'IBM863',
 	'IBM864' => 'IBM864',
 	'IBM865' => 'IBM865',
 	'IBM866' => 'IBM866',
 	'IBM868' => 'IBM868',
 	'IBM869' => 'IBM869',
 	'IBM870' => 'IBM870',
 	'IBM871' => 'IBM871',
 	'IBM874' => 'IBM874',
 	'IBM875' => 'IBM875',
 	'IBM880' => 'IBM880',
 	'IBM891' => 'IBM891',
 	'IBM903' => 'IBM903',
 	'IBM904' => 'IBM904',
 	'IBM905' => 'IBM905',
 	'IBM918' => 'IBM918',
 	'IEC_P27-1' => 'IEC_P27_1',
 	'INIS-8' => 'INIS_8',
 	'INIS-CYRILLIC' => 'INIS_CYRILLIC',
 	'INIS' => 'INIS',
 	'ISO-8859-1' => 'ISO_8859_1',
 	'ISO-8859-10' => 'ISO_8859_10',
 	'ISO-8859-11' => 'ISO_8859_11',
 	'ISO-8859-13' => 'ISO_8859_13',
 	'ISO-8859-14' => 'ISO_8859_14',
 	'ISO-8859-15' => 'ISO_8859_15',
 	'ISO-8859-16' => 'ISO_8859_16',
 	'ISO-8859-2' => 'ISO_8859_2',
 	'ISO-8859-3' => 'ISO_8859_3',
 	'ISO-8859-4' => 'ISO_8859_4',
 	'ISO-8859-5' => 'ISO_8859_5',
 	'ISO-8859-6' => 'ISO_8859_6',
 	'ISO-8859-7' => 'ISO_8859_7',
 	'ISO-8859-8' => 'ISO_8859_8',
 	'ISO-8859-9' => 'ISO_8859_9',
 	'ISO_10367-BOX' => 'ISO_10367_BOX',
 	'ISO_2033-1983' => 'ISO_2033_1983',
 	'ISO_5427-EXT' => 'ISO_5427_EXT',
 	'ISO_5427' => 'ISO_5427',
 	'ISO_5428' => 'ISO_5428',
 	'KOI-8' => 'KOI_8',
 	'KOI8-R' => 'KOI8_R',
 	'KOI8-RU' => 'KOI8_RU',
 	'KOI8-T' => 'KOI8_T',
 	'KOI8-U' => 'KOI8_U',
 	'LATIN-GREEK-1' => 'LATIN_GREEK_1',
 	'LATIN-GREEK' => 'LATIN_GREEK',
 	'MACINTOSH' => 'MACINTOSH',
 	'MACARABIC' => 'MACARABIC',
 	'MACCYRILLIC' => 'MACCYRILLIC',
 	'MACCROATIAN' => 'MACCROATIAN',
 	'MACGREEK' => 'MACGREEK',
 	'MACHEBREW' => 'MACHEBREW',
 	'MACICELAND' => 'MACICELAND',
 	'MACROMANIA' => 'MACROMANIA',
 	'MACTHAI' => 'MACTHAI',
 	'MACTURKISH' => 'MACTURKISH',
 	'MACUKRAINE' => 'MACUKRAINE',
 	'MAC-IS' => 'MAC_IS',
 	'MAC-SAMI' => 'MAC_SAMI',
 	'MAC-UK' => 'MAC_UK',
 	'NATS-DANO' => 'NATS_DANO',
 	'NATS-SEFI' => 'NATS_SEFI',
 	'NEXTSTEP' => 'NEXTSTEP',
 	'TIS-620' => 'TIS_620',
 	'UTF-8' => 'UTF_8',
 	'VISCII' => 'VISCII',
 	'WIN-SAMI-2' => 'SAMI_WS2',
 	'WINDOWS-1250' => 'CP1250',
 	'WINDOWS-1251' => 'CP1251',
 	'WINDOWS-1252' => 'CP1252',
 	'WINDOWS-1253' => 'CP1253',
 	'WINDOWS-1254' => 'CP1254',
 	'WINDOWS-1256' => 'CP1256',
 	'WINDOWS-1257' => 'CP1257',
 	'US-ASCII' => 'US_ASCII',
 };
 
 $optional_conversions = {
 	'BIG5' => undef,
 	'BIG5-HKSCS' => undef,
 	'CN-GB' => undef,
 	'CN-GB-ISOIR165' => undef,
 	'CP1006' => undef,
 	'CP1026' => undef,
 	'CP1047' => undef,
 	'CP1361' => undef,
 	'CP949' => undef,
     'CP37' => undef,
     'CP424' => undef,
     'CP500' => undef,
     'CP737' => undef,
     'CP775' => undef,
     'CP856' => undef,
     'CP874' => undef,
     'CP875' => undef,
     'CP932' => undef,
     'CP936' => undef,
     'CP950' => undef,
 	'EUC-JP' => undef,
 	'EUC-KR' => undef,
 	'EUC-TW' => undef,
 	'GB18030' => undef,
 	'HZ' => undef,
 	'IBM437' => undef,
 	'IBM850' => undef,
 	'IBM852' => undef,
 	'IBM855' => undef,
 	'IBM857' => undef,
 	'IBM860' => undef,
 	'IBM861' => undef,
 	'IBM862' => undef,
 	'IBM863' => undef,
 	'IBM864' => undef,
 	'IBM865' => undef,
 	'IBM866' => undef,
 	'IBM869' => undef,
 	'ISO-10646-UCS-2' => undef,
 	'ISO-10646-UCS-4' => undef,
 	'ISO-2022-JP' => undef,
 	'ISO-2022-JP-1' => undef,
 	'ISO-2022-KR' => undef,
 	'ISO-8859-1' => undef,
 	'ISO-8859-10' => undef,
 	'ISO-8859-13' => undef,
 	'ISO-8859-14' => undef,
 	'ISO-8859-15' => undef,
 	'ISO-8859-2' => undef,
 	'ISO-8859-3' => undef,
 	'ISO-8859-4' => undef,
 	'ISO-8859-5' => undef,
 	'ISO-8859-9' => undef,
 	'ISO-IR-149' => undef,
 	'KOI8-R' => undef,
 	'SHIFT_JIS' => undef,
 	'UCS-2BE' => undef,
 	'UCS-2LE' => undef,
 	'UCS-4BE' => undef,
 	'UCS-4LE' => undef,
 	'US-ASCII' => undef,
 	'UTF-16' => undef,
 	'UTF-16BE' => undef,
 	'UTF-16LE' => undef,
 	'UTF-32' => undef,
 	'UTF-32BE' => undef,
 	'UTF-32LE' => undef,
 	'UTF-8' => undef,
 	'WINDOWS-1250' => undef,
 	'WINDOWS-1251' => undef,
 	'WINDOWS-1252' => undef,
 	'WINDOWS-1253' => undef,
 	'WINDOWS-1254' => undef,
 	'WINDOWS-1255' => undef,
 	'WINDOWS-1256' => undef,
 	'WINDOWS-1257' => undef,
 	'WINDOWS-1258' => undef,
 };
 
 my $has_encode;
 
 sub resolveAlias
 {
 	my (undef, $encoding) = @_;
 
 	$encoding = uc $encoding;
 	
 	return $encoding if exists $conversions->{$encoding};
 	return $encoding if exists $optional_conversions->{$encoding};
 
 	require Locale::Recode::_Aliases;
 
 	my $resolved = Locale::Recode::_Aliases::ALIASES()->{$encoding};
 	
 	return $resolved if $resolved;
 
 	return;
 }
 
 sub isSupported
 {
 	my ($class, $encoding) = @_;
 
 	return unless defined $encoding && length $encoding;
 
 	$encoding = uc $encoding;
 	my $mimename = $class->resolveAlias ($encoding);
 
 	return unless $mimename;
 	
 	if (exists $optional_conversions->{$mimename}) {
 		unless (defined $has_encode) {
 			eval "require Encode";
 			$has_encode = !$@;
 
 			if ($has_encode) {
 				require Encode::Alias;
 
 				Encode::Alias::define_alias (MS_KANJI => 'ShiftJIS');
 				Encode::Alias::define_alias ('CN-GB' => 'EUC-CN');
 			}
 		}
 
 		if ($has_encode) {
 			eval "Encode::encode ('$mimename', 'x')";
 		
 			unless ($@) {
 				$conversions->{$mimename} = '_Encode';
 			}
 			delete $optional_conversions->{$mimename};
 		}
 	}
 
 	return $conversions->{$mimename} if exists $conversions->{$mimename};
 
 	return;
 }
 
 sub listSupported
 {
 	my ($class) = @_;
 
 	foreach my $opt (keys %$optional_conversions) {
 		$class->isSupported ($opt);
 	}
 
 	my @list = keys %$conversions;
 	return @list;
 }
 
 sub findPath
 {
 	my ($class, $from, $to) = @_;
 
 	$from = 'INTERNAL' eq uc $from ? 'INTERNAL' : $class->resolveAlias ($from);
 	$to = 'INTERNAL' eq uc $to ? 'INTERNAL' : $class->resolveAlias ($to);
 	
 	return unless $from && $to;
 	
 	return [] if $from eq $to;
 
 	my $from_module = $class->isSupported ($from);
 	my $to_module = $class->isSupported ($to);
 
 	if (!$from_module) {
 		if ('INTERNAL' eq $from) {
 			$from_module = $to_module or return;
 		} else {
 			return;
 		}
 	}
 
 	if (!$to_module) {
 		if ('INTERNAL' eq $to) {
 			$to_module = $from_module or return;
 		} else {
 			return;
 		}
 	}
 
 	if ($from_module eq $to_module
 		|| $to eq 'INTERNAL'
 		|| $to eq 'UTF-8') {
 		return [[ $from_module, $from, $to ]];
 	} elsif ($from eq 'INTERNAL') {
 		return [[ $to_module, $from, $to ]];
 	} else {
 		return [[ $from_module, $from, 'INTERNAL' ],
 				[ $to_module, 'INTERNAL', $to ]];
 	}
 }
 
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData.pm ###
 #! /bin/false
 
 
 
 
 
 
 package Locale::RecodeData;
 
 use strict;
 
 sub new
 {
     my ($class, %args) = @_;
 
     bless {
 		_from => $args{from},
 		_to => $args{to},
     }, $class;
 }
 
 sub _getError
 {
 	shift->{_error};
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ASMO_449.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ASMO_449;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x00a4,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x060c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x061b,
     0x003c,
     0x003d,
     0x003e,
     0x061f,
     0x0040,
     0x0621,
     0x0622,
     0x0623,
     0x0624,
     0x0625,
     0x0626,
     0x0627,
     0x0628,
     0x0629,
     0x062a,
     0x062b,
     0x062c,
     0x062d,
     0x062e,
     0x062f,
     0x0630,
     0x0631,
     0x0632,
     0x0633,
     0x0634,
     0x0635,
     0x0636,
     0x0637,
     0x0638,
     0x0639,
     0x063a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0640,
     0x0641,
     0x0642,
     0x0643,
     0x0644,
     0x0645,
     0x0646,
     0x0647,
     0x0648,
     0x0649,
     0x064a,
     0x064b,
     0x064c,
     0x064d,
     0x064e,
     0x064f,
     0x0650,
     0x0651,
     0x0652,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007b,
     0x007c,
     0x007d,
     0x203e,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\xc2\xa4",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\xd8\x8c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\xd8\x9b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\xd8\x9f",
     "\x40",
     "\xd8\xa1",
     "\xd8\xa2",
     "\xd8\xa3",
     "\xd8\xa4",
     "\xd8\xa5",
     "\xd8\xa6",
     "\xd8\xa7",
     "\xd8\xa8",
     "\xd8\xa9",
     "\xd8\xaa",
     "\xd8\xab",
     "\xd8\xac",
     "\xd8\xad",
     "\xd8\xae",
     "\xd8\xaf",
     "\xd8\xb0",
     "\xd8\xb1",
     "\xd8\xb2",
     "\xd8\xb3",
     "\xd8\xb4",
     "\xd8\xb5",
     "\xd8\xb6",
     "\xd8\xb7",
     "\xd8\xb8",
     "\xd8\xb9",
     "\xd8\xba",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\xd9\x80",
     "\xd9\x81",
     "\xd9\x82",
     "\xd9\x83",
     "\xd9\x84",
     "\xd9\x85",
     "\xd9\x86",
     "\xd9\x87",
     "\xd9\x88",
     "\xd9\x89",
     "\xd9\x8a",
     "\xd9\x8b",
     "\xd9\x8c",
     "\xd9\x8d",
     "\xd9\x8e",
     "\xd9\x8f",
     "\xd9\x90",
     "\xd9\x91",
     "\xd9\x92",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7b",
     "\x7c",
     "\x7d",
     "\xe2\x80\xbe",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x00000040 => "\x40",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007f => "\x7f",
     0x000000a4 => "\x24",
     0x0000060c => "\x2c",
     0x0000061b => "\x3b",
     0x0000061f => "\x3f",
     0x00000621 => "\x41",
     0x00000622 => "\x42",
     0x00000623 => "\x43",
     0x00000624 => "\x44",
     0x00000625 => "\x45",
     0x00000626 => "\x46",
     0x00000627 => "\x47",
     0x00000628 => "\x48",
     0x00000629 => "\x49",
     0x0000062a => "\x4a",
     0x0000062b => "\x4b",
     0x0000062c => "\x4c",
     0x0000062d => "\x4d",
     0x0000062e => "\x4e",
     0x0000062f => "\x4f",
     0x00000630 => "\x50",
     0x00000631 => "\x51",
     0x00000632 => "\x52",
     0x00000633 => "\x53",
     0x00000634 => "\x54",
     0x00000635 => "\x55",
     0x00000636 => "\x56",
     0x00000637 => "\x57",
     0x00000638 => "\x58",
     0x00000639 => "\x59",
     0x0000063a => "\x5a",
     0x00000640 => "\x60",
     0x00000641 => "\x61",
     0x00000642 => "\x62",
     0x00000643 => "\x63",
     0x00000644 => "\x64",
     0x00000645 => "\x65",
     0x00000646 => "\x66",
     0x00000647 => "\x67",
     0x00000648 => "\x68",
     0x00000649 => "\x69",
     0x0000064a => "\x6a",
     0x0000064b => "\x6b",
     0x0000064c => "\x6c",
     0x0000064d => "\x6d",
     0x0000064e => "\x6e",
     0x0000064f => "\x6f",
     0x00000650 => "\x70",
     0x00000651 => "\x71",
     0x00000652 => "\x72",
     0x0000203e => "\x7e",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ATARI_ST.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ATARI_ST;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e5,
     0x00e7,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ef,
     0x00ee,
     0x00ec,
     0x00c4,
     0x00c5,
     0x00c9,
     0x00e6,
     0x00c6,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00fb,
     0x00f9,
     0x00ff,
     0x00d6,
     0x00dc,
     0x00a2,
     0x00a3,
     0x00a5,
     0x00df,
     0x0192,
     0x00e1,
     0x00ed,
     0x00f3,
     0x00fa,
     0x00f1,
     0x00d1,
     0x00aa,
     0x00ba,
     0x00bf,
     0x2310,
     0x00ac,
     0x00bd,
     0x00bc,
     0x00a1,
     0x00ab,
     0x00bb,
     0x00e3,
     0x00f5,
     0x00d8,
     0x00f8,
     0x0153,
     0x0152,
     0x00c0,
     0x00c3,
     0x00d5,
     0x00a8,
     0x00b4,
     0x2020,
     0x00b6,
     0x00a9,
     0x00ae,
     0x2122,
     0x0133,
     0x0132,
     0x05d0,
     0x05d1,
     0x05d2,
     0x05d3,
     0x05d4,
     0x05d5,
     0x05d6,
     0x05d7,
     0x05d8,
     0x05d9,
     0x05db,
     0x05dc,
     0x05de,
     0x05e0,
     0x05e1,
     0x05e2,
     0x05e4,
     0x05e6,
     0x05e7,
     0x05e8,
     0x05e9,
     0x05ea,
     0x05df,
     0x05da,
     0x05dd,
     0x05e3,
     0x05e5,
     0x00a7,
     0x2038,
     0x221e,
     0x03b1,
     0x03b2,
     0x0393,
     0x03c0,
     0x03a3,
     0x03c3,
     0x00b5,
     0x03c4,
     0x03a6,
     0x03b8,
     0x03a9,
     0x03b4,
     0x222e,
     0x03c6,
     0x2208,
     0x220f,
     0x2261,
     0x00b1,
     0x2265,
     0x2264,
     0x2320,
     0x2321,
     0x00f7,
     0x2248,
     0x00b0,
     0x2022,
     0x00b7,
     0x221a,
     0x207f,
     0x00b2,
     0x00b3,
     0x00af,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xaf",
     "\xc3\xae",
     "\xc3\xac",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x89",
     "\xc3\xa6",
     "\xc3\x86",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xbb",
     "\xc3\xb9",
     "\xc3\xbf",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc3\x9f",
     "\xc6\x92",
     "\xc3\xa1",
     "\xc3\xad",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc3\xb1",
     "\xc3\x91",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc2\xbf",
     "\xe2\x8c\x90",
     "\xc2\xac",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xc2\xa1",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xa3",
     "\xc3\xb5",
     "\xc3\x98",
     "\xc3\xb8",
     "\xc5\x93",
     "\xc5\x92",
     "\xc3\x80",
     "\xc3\x83",
     "\xc3\x95",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xe2\x80\xa0",
     "\xc2\xb6",
     "\xc2\xa9",
     "\xc2\xae",
     "\xe2\x84\xa2",
     "\xc4\xb3",
     "\xc4\xb2",
     "\xd7\x90",
     "\xd7\x91",
     "\xd7\x92",
     "\xd7\x93",
     "\xd7\x94",
     "\xd7\x95",
     "\xd7\x96",
     "\xd7\x97",
     "\xd7\x98",
     "\xd7\x99",
     "\xd7\x9b",
     "\xd7\x9c",
     "\xd7\x9e",
     "\xd7\xa0",
     "\xd7\xa1",
     "\xd7\xa2",
     "\xd7\xa4",
     "\xd7\xa6",
     "\xd7\xa7",
     "\xd7\xa8",
     "\xd7\xa9",
     "\xd7\xaa",
     "\xd7\x9f",
     "\xd7\x9a",
     "\xd7\x9d",
     "\xd7\xa3",
     "\xd7\xa5",
     "\xc2\xa7",
     "\xe2\x80\xb8",
     "\xe2\x88\x9e",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\x93",
     "\xcf\x80",
     "\xce\xa3",
     "\xcf\x83",
     "\xc2\xb5",
     "\xcf\x84",
     "\xce\xa6",
     "\xce\xb8",
     "\xce\xa9",
     "\xce\xb4",
     "\xe2\x88\xae",
     "\xcf\x86",
     "\xe2\x88\x88",
     "\xe2\x88\x8f",
     "\xe2\x89\xa1",
     "\xc2\xb1",
     "\xe2\x89\xa5",
     "\xe2\x89\xa4",
     "\xe2\x8c\xa0",
     "\xe2\x8c\xa1",
     "\xc3\xb7",
     "\xe2\x89\x88",
     "\xc2\xb0",
     "\xe2\x80\xa2",
     "\xc2\xb7",
     "\xe2\x88\x9a",
     "\xe2\x81\xbf",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xaf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a1 => "\xad",
     0x000000a2 => "\x9b",
     0x000000a3 => "\x9c",
     0x000000a5 => "\x9d",
     0x000000a7 => "\xdd",
     0x000000a8 => "\xb9",
     0x000000a9 => "\xbd",
     0x000000aa => "\xa6",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000ae => "\xbe",
     0x000000af => "\xff",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b2 => "\xfd",
     0x000000b3 => "\xfe",
     0x000000b4 => "\xba",
     0x000000b5 => "\xe6",
     0x000000b6 => "\xbc",
     0x000000b7 => "\xfa",
     0x000000ba => "\xa7",
     0x000000bb => "\xaf",
     0x000000bc => "\xac",
     0x000000bd => "\xab",
     0x000000bf => "\xa8",
     0x000000c0 => "\xb6",
     0x000000c3 => "\xb7",
     0x000000c4 => "\x8e",
     0x000000c5 => "\x8f",
     0x000000c6 => "\x92",
     0x000000c7 => "\x80",
     0x000000c9 => "\x90",
     0x000000d1 => "\xa5",
     0x000000d5 => "\xb8",
     0x000000d6 => "\x99",
     0x000000d8 => "\xb2",
     0x000000dc => "\x9a",
     0x000000df => "\x9e",
     0x000000e0 => "\x85",
     0x000000e1 => "\xa0",
     0x000000e2 => "\x83",
     0x000000e3 => "\xb0",
     0x000000e4 => "\x84",
     0x000000e5 => "\x86",
     0x000000e6 => "\x91",
     0x000000e7 => "\x87",
     0x000000e8 => "\x8a",
     0x000000e9 => "\x82",
     0x000000ea => "\x88",
     0x000000eb => "\x89",
     0x000000ec => "\x8d",
     0x000000ed => "\xa1",
     0x000000ee => "\x8c",
     0x000000ef => "\x8b",
     0x000000f1 => "\xa4",
     0x000000f2 => "\x95",
     0x000000f3 => "\xa2",
     0x000000f4 => "\x93",
     0x000000f5 => "\xb1",
     0x000000f6 => "\x94",
     0x000000f7 => "\xf6",
     0x000000f8 => "\xb3",
     0x000000f9 => "\x97",
     0x000000fa => "\xa3",
     0x000000fb => "\x96",
     0x000000fc => "\x81",
     0x000000ff => "\x98",
     0x00000132 => "\xc1",
     0x00000133 => "\xc0",
     0x00000152 => "\xb5",
     0x00000153 => "\xb4",
     0x00000192 => "\x9f",
     0x00000393 => "\xe2",
     0x000003a3 => "\xe4",
     0x000003a6 => "\xe8",
     0x000003a9 => "\xea",
     0x000003b1 => "\xe0",
     0x000003b2 => "\xe1",
     0x000003b4 => "\xeb",
     0x000003b8 => "\xe9",
     0x000003c0 => "\xe3",
     0x000003c3 => "\xe5",
     0x000003c4 => "\xe7",
     0x000003c6 => "\xed",
     0x000005d0 => "\xc2",
     0x000005d1 => "\xc3",
     0x000005d2 => "\xc4",
     0x000005d3 => "\xc5",
     0x000005d4 => "\xc6",
     0x000005d5 => "\xc7",
     0x000005d6 => "\xc8",
     0x000005d7 => "\xc9",
     0x000005d8 => "\xca",
     0x000005d9 => "\xcb",
     0x000005da => "\xd9",
     0x000005db => "\xcc",
     0x000005dc => "\xcd",
     0x000005dd => "\xda",
     0x000005de => "\xce",
     0x000005df => "\xd8",
     0x000005e0 => "\xcf",
     0x000005e1 => "\xd0",
     0x000005e2 => "\xd1",
     0x000005e3 => "\xdb",
     0x000005e4 => "\xd2",
     0x000005e5 => "\xdc",
     0x000005e6 => "\xd3",
     0x000005e7 => "\xd4",
     0x000005e8 => "\xd5",
     0x000005e9 => "\xd6",
     0x000005ea => "\xd7",
     0x00002020 => "\xbb",
     0x00002022 => "\xf9",
     0x00002038 => "\xde",
     0x0000207f => "\xfc",
     0x00002122 => "\xbf",
     0x00002208 => "\xee",
     0x0000220f => "\xef",
     0x0000221a => "\xfb",
     0x0000221e => "\xdf",
     0x0000222e => "\xec",
     0x00002248 => "\xf7",
     0x00002261 => "\xf0",
     0x00002264 => "\xf3",
     0x00002265 => "\xf2",
     0x00002310 => "\xa9",
     0x00002320 => "\xf4",
     0x00002321 => "\xf5",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ATARI_ST_EURO.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ATARI_ST_EURO;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e5,
     0x00e7,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ef,
     0x00ee,
     0x00ec,
     0x00c4,
     0x00c5,
     0x00c9,
     0x00e6,
     0x00c6,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00fb,
     0x00f9,
     0x00ff,
     0x00d6,
     0x00dc,
     0x00a2,
     0x00a3,
     0x00a5,
     0x00df,
     0x0192,
     0x00e1,
     0x00ed,
     0x00f3,
     0x00fa,
     0x00f1,
     0x00d1,
     0x00aa,
     0x00ba,
     0x00bf,
     0x2310,
     0x00ac,
     0x00bd,
     0x00bc,
     0x00a1,
     0x00ab,
     0x00bb,
     0x00e3,
     0x00f5,
     0x00d8,
     0x00f8,
     0x0153,
     0x0152,
     0x00c0,
     0x00c3,
     0x00d5,
     0x00a8,
     0x00b4,
     0x2020,
     0x00b6,
     0x00a9,
     0x00ae,
     0x2122,
     0x0133,
     0x0132,
     0x05d0,
     0x05d1,
     0x05d2,
     0x05d3,
     0x05d4,
     0x05d5,
     0x05d6,
     0x05d7,
     0x05d8,
     0x05d9,
     0x05db,
     0x05dc,
     0x05de,
     0x05e0,
     0x05e1,
     0x05e2,
     0x05e4,
     0x05e6,
     0x05e7,
     0x05e8,
     0x05e9,
     0x05ea,
     0x05df,
     0x05da,
     0x05dd,
     0x05e3,
     0x05e5,
     0x00a7,
     0x20ac,
     0x221e,
     0x03b1,
     0x03b2,
     0x0393,
     0x03c0,
     0x03a3,
     0x03c3,
     0x00b5,
     0x03c4,
     0x03a6,
     0x03b8,
     0x03a9,
     0x03b4,
     0x222e,
     0x03c6,
     0x2208,
     0x220f,
     0x2261,
     0x00b1,
     0x2265,
     0x2264,
     0x2320,
     0x2321,
     0x00f7,
     0x2248,
     0x00b0,
     0x2022,
     0x00b7,
     0x221a,
     0x207f,
     0x00b2,
     0x00b3,
     0x00af,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xaf",
     "\xc3\xae",
     "\xc3\xac",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x89",
     "\xc3\xa6",
     "\xc3\x86",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xbb",
     "\xc3\xb9",
     "\xc3\xbf",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc3\x9f",
     "\xc6\x92",
     "\xc3\xa1",
     "\xc3\xad",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc3\xb1",
     "\xc3\x91",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc2\xbf",
     "\xe2\x8c\x90",
     "\xc2\xac",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xc2\xa1",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xa3",
     "\xc3\xb5",
     "\xc3\x98",
     "\xc3\xb8",
     "\xc5\x93",
     "\xc5\x92",
     "\xc3\x80",
     "\xc3\x83",
     "\xc3\x95",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xe2\x80\xa0",
     "\xc2\xb6",
     "\xc2\xa9",
     "\xc2\xae",
     "\xe2\x84\xa2",
     "\xc4\xb3",
     "\xc4\xb2",
     "\xd7\x90",
     "\xd7\x91",
     "\xd7\x92",
     "\xd7\x93",
     "\xd7\x94",
     "\xd7\x95",
     "\xd7\x96",
     "\xd7\x97",
     "\xd7\x98",
     "\xd7\x99",
     "\xd7\x9b",
     "\xd7\x9c",
     "\xd7\x9e",
     "\xd7\xa0",
     "\xd7\xa1",
     "\xd7\xa2",
     "\xd7\xa4",
     "\xd7\xa6",
     "\xd7\xa7",
     "\xd7\xa8",
     "\xd7\xa9",
     "\xd7\xaa",
     "\xd7\x9f",
     "\xd7\x9a",
     "\xd7\x9d",
     "\xd7\xa3",
     "\xd7\xa5",
     "\xc2\xa7",
     "\xe2\x82\xac",
     "\xe2\x88\x9e",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\x93",
     "\xcf\x80",
     "\xce\xa3",
     "\xcf\x83",
     "\xc2\xb5",
     "\xcf\x84",
     "\xce\xa6",
     "\xce\xb8",
     "\xce\xa9",
     "\xce\xb4",
     "\xe2\x88\xae",
     "\xcf\x86",
     "\xe2\x88\x88",
     "\xe2\x88\x8f",
     "\xe2\x89\xa1",
     "\xc2\xb1",
     "\xe2\x89\xa5",
     "\xe2\x89\xa4",
     "\xe2\x8c\xa0",
     "\xe2\x8c\xa1",
     "\xc3\xb7",
     "\xe2\x89\x88",
     "\xc2\xb0",
     "\xe2\x80\xa2",
     "\xc2\xb7",
     "\xe2\x88\x9a",
     "\xe2\x81\xbf",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xaf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a1 => "\xad",
     0x000000a2 => "\x9b",
     0x000000a3 => "\x9c",
     0x000000a5 => "\x9d",
     0x000000a7 => "\xdd",
     0x000000a8 => "\xb9",
     0x000000a9 => "\xbd",
     0x000000aa => "\xa6",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000ae => "\xbe",
     0x000000af => "\xff",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b2 => "\xfd",
     0x000000b3 => "\xfe",
     0x000000b4 => "\xba",
     0x000000b5 => "\xe6",
     0x000000b6 => "\xbc",
     0x000000b7 => "\xfa",
     0x000000ba => "\xa7",
     0x000000bb => "\xaf",
     0x000000bc => "\xac",
     0x000000bd => "\xab",
     0x000000bf => "\xa8",
     0x000000c0 => "\xb6",
     0x000000c3 => "\xb7",
     0x000000c4 => "\x8e",
     0x000000c5 => "\x8f",
     0x000000c6 => "\x92",
     0x000000c7 => "\x80",
     0x000000c9 => "\x90",
     0x000000d1 => "\xa5",
     0x000000d5 => "\xb8",
     0x000000d6 => "\x99",
     0x000000d8 => "\xb2",
     0x000000dc => "\x9a",
     0x000000df => "\x9e",
     0x000000e0 => "\x85",
     0x000000e1 => "\xa0",
     0x000000e2 => "\x83",
     0x000000e3 => "\xb0",
     0x000000e4 => "\x84",
     0x000000e5 => "\x86",
     0x000000e6 => "\x91",
     0x000000e7 => "\x87",
     0x000000e8 => "\x8a",
     0x000000e9 => "\x82",
     0x000000ea => "\x88",
     0x000000eb => "\x89",
     0x000000ec => "\x8d",
     0x000000ed => "\xa1",
     0x000000ee => "\x8c",
     0x000000ef => "\x8b",
     0x000000f1 => "\xa4",
     0x000000f2 => "\x95",
     0x000000f3 => "\xa2",
     0x000000f4 => "\x93",
     0x000000f5 => "\xb1",
     0x000000f6 => "\x94",
     0x000000f7 => "\xf6",
     0x000000f8 => "\xb3",
     0x000000f9 => "\x97",
     0x000000fa => "\xa3",
     0x000000fb => "\x96",
     0x000000fc => "\x81",
     0x000000ff => "\x98",
     0x00000132 => "\xc1",
     0x00000133 => "\xc0",
     0x00000152 => "\xb5",
     0x00000153 => "\xb4",
     0x00000192 => "\x9f",
     0x00000393 => "\xe2",
     0x000003a3 => "\xe4",
     0x000003a6 => "\xe8",
     0x000003a9 => "\xea",
     0x000003b1 => "\xe0",
     0x000003b2 => "\xe1",
     0x000003b4 => "\xeb",
     0x000003b8 => "\xe9",
     0x000003c0 => "\xe3",
     0x000003c3 => "\xe5",
     0x000003c4 => "\xe7",
     0x000003c6 => "\xed",
     0x000005d0 => "\xc2",
     0x000005d1 => "\xc3",
     0x000005d2 => "\xc4",
     0x000005d3 => "\xc5",
     0x000005d4 => "\xc6",
     0x000005d5 => "\xc7",
     0x000005d6 => "\xc8",
     0x000005d7 => "\xc9",
     0x000005d8 => "\xca",
     0x000005d9 => "\xcb",
     0x000005da => "\xd9",
     0x000005db => "\xcc",
     0x000005dc => "\xcd",
     0x000005dd => "\xda",
     0x000005de => "\xce",
     0x000005df => "\xd8",
     0x000005e0 => "\xcf",
     0x000005e1 => "\xd0",
     0x000005e2 => "\xd1",
     0x000005e3 => "\xdb",
     0x000005e4 => "\xd2",
     0x000005e5 => "\xdc",
     0x000005e6 => "\xd3",
     0x000005e7 => "\xd4",
     0x000005e8 => "\xd5",
     0x000005e9 => "\xd6",
     0x000005ea => "\xd7",
     0x00002020 => "\xbb",
     0x00002022 => "\xf9",
     0x0000207f => "\xfc",
     0x000020ac => "\xde",
     0x00002122 => "\xbf",
     0x00002208 => "\xee",
     0x0000220f => "\xef",
     0x0000221a => "\xfb",
     0x0000221e => "\xdf",
     0x0000222e => "\xec",
     0x00002248 => "\xf7",
     0x00002261 => "\xf0",
     0x00002264 => "\xf3",
     0x00002265 => "\xf2",
     0x00002310 => "\xa9",
     0x00002320 => "\xf4",
     0x00002321 => "\xf5",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/CP10007.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::CP10007;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0410,
     0x0411,
     0x0412,
     0x0413,
     0x0414,
     0x0415,
     0x0416,
     0x0417,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0424,
     0x0425,
     0x0426,
     0x0427,
     0x0428,
     0x0429,
     0x042a,
     0x042b,
     0x042c,
     0x042d,
     0x042e,
     0x042f,
     0x2020,
     0x00b0,
     0x00a2,
     0x00a3,
     0x00a7,
     0x2022,
     0x00b6,
     0x0406,
     0x00ae,
     0x00a9,
     0x2122,
     0x0402,
     0x0452,
     0x2260,
     0x0403,
     0x0453,
     0x221e,
     0x00b1,
     0x2264,
     0x2265,
     0x0456,
     0x00b5,
     0x0491,
     0x0408,
     0x0404,
     0x0454,
     0x0407,
     0x0457,
     0x0409,
     0x0459,
     0x040a,
     0x045a,
     0x0458,
     0x0405,
     0x00ac,
     0x221a,
     0x0192,
     0x2248,
     0x2206,
     0x00ab,
     0x00bb,
     0x2026,
     0x00a0,
     0x040b,
     0x045b,
     0x040c,
     0x045c,
     0x0455,
     0x2013,
     0x2014,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x201e,
     0x040e,
     0x045e,
     0x040f,
     0x045f,
     0x2116,
     0x0401,
     0x0451,
     0x044f,
     0x0430,
     0x0431,
     0x0432,
     0x0433,
     0x0434,
     0x0435,
     0x0436,
     0x0437,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0444,
     0x0445,
     0x0446,
     0x0447,
     0x0448,
     0x0449,
     0x044a,
     0x044b,
     0x044c,
     0x044d,
     0x044e,
     0x00a4,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\x92",
     "\xd0\x93",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\x96",
     "\xd0\x97",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\xa4",
     "\xd0\xa5",
     "\xd0\xa6",
     "\xd0\xa7",
     "\xd0\xa8",
     "\xd0\xa9",
     "\xd0\xaa",
     "\xd0\xab",
     "\xd0\xac",
     "\xd0\xad",
     "\xd0\xae",
     "\xd0\xaf",
     "\xe2\x80\xa0",
     "\xc2\xb0",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa7",
     "\xe2\x80\xa2",
     "\xc2\xb6",
     "\xd0\x86",
     "\xc2\xae",
     "\xc2\xa9",
     "\xe2\x84\xa2",
     "\xd0\x82",
     "\xd1\x92",
     "\xe2\x89\xa0",
     "\xd0\x83",
     "\xd1\x93",
     "\xe2\x88\x9e",
     "\xc2\xb1",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xd1\x96",
     "\xc2\xb5",
     "\xd2\x91",
     "\xd0\x88",
     "\xd0\x84",
     "\xd1\x94",
     "\xd0\x87",
     "\xd1\x97",
     "\xd0\x89",
     "\xd1\x99",
     "\xd0\x8a",
     "\xd1\x9a",
     "\xd1\x98",
     "\xd0\x85",
     "\xc2\xac",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x89\x88",
     "\xe2\x88\x86",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xd0\x8b",
     "\xd1\x9b",
     "\xd0\x8c",
     "\xd1\x9c",
     "\xd1\x95",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xe2\x80\x9e",
     "\xd0\x8e",
     "\xd1\x9e",
     "\xd0\x8f",
     "\xd1\x9f",
     "\xe2\x84\x96",
     "\xd0\x81",
     "\xd1\x91",
     "\xd1\x8f",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd0\xb2",
     "\xd0\xb3",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd0\xb6",
     "\xd0\xb7",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd1\x84",
     "\xd1\x85",
     "\xd1\x86",
     "\xd1\x87",
     "\xd1\x88",
     "\xd1\x89",
     "\xd1\x8a",
     "\xd1\x8b",
     "\xd1\x8c",
     "\xd1\x8d",
     "\xd1\x8e",
     "\xc2\xa4",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xff",
     0x000000a7 => "\xa4",
     0x000000a9 => "\xa9",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ae => "\xa8",
     0x000000b0 => "\xa1",
     0x000000b1 => "\xb1",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xa6",
     0x000000bb => "\xc8",
     0x000000f7 => "\xd6",
     0x00000192 => "\xc4",
     0x00000401 => "\xdd",
     0x00000402 => "\xab",
     0x00000403 => "\xae",
     0x00000404 => "\xb8",
     0x00000405 => "\xc1",
     0x00000406 => "\xa7",
     0x00000407 => "\xba",
     0x00000408 => "\xb7",
     0x00000409 => "\xbc",
     0x0000040a => "\xbe",
     0x0000040b => "\xcb",
     0x0000040c => "\xcd",
     0x0000040e => "\xd8",
     0x0000040f => "\xda",
     0x00000410 => "\x80",
     0x00000411 => "\x81",
     0x00000412 => "\x82",
     0x00000413 => "\x83",
     0x00000414 => "\x84",
     0x00000415 => "\x85",
     0x00000416 => "\x86",
     0x00000417 => "\x87",
     0x00000418 => "\x88",
     0x00000419 => "\x89",
     0x0000041a => "\x8a",
     0x0000041b => "\x8b",
     0x0000041c => "\x8c",
     0x0000041d => "\x8d",
     0x0000041e => "\x8e",
     0x0000041f => "\x8f",
     0x00000420 => "\x90",
     0x00000421 => "\x91",
     0x00000422 => "\x92",
     0x00000423 => "\x93",
     0x00000424 => "\x94",
     0x00000425 => "\x95",
     0x00000426 => "\x96",
     0x00000427 => "\x97",
     0x00000428 => "\x98",
     0x00000429 => "\x99",
     0x0000042a => "\x9a",
     0x0000042b => "\x9b",
     0x0000042c => "\x9c",
     0x0000042d => "\x9d",
     0x0000042e => "\x9e",
     0x0000042f => "\x9f",
     0x00000430 => "\xe0",
     0x00000431 => "\xe1",
     0x00000432 => "\xe2",
     0x00000433 => "\xe3",
     0x00000434 => "\xe4",
     0x00000435 => "\xe5",
     0x00000436 => "\xe6",
     0x00000437 => "\xe7",
     0x00000438 => "\xe8",
     0x00000439 => "\xe9",
     0x0000043a => "\xea",
     0x0000043b => "\xeb",
     0x0000043c => "\xec",
     0x0000043d => "\xed",
     0x0000043e => "\xee",
     0x0000043f => "\xef",
     0x00000440 => "\xf0",
     0x00000441 => "\xf1",
     0x00000442 => "\xf2",
     0x00000443 => "\xf3",
     0x00000444 => "\xf4",
     0x00000445 => "\xf5",
     0x00000446 => "\xf6",
     0x00000447 => "\xf7",
     0x00000448 => "\xf8",
     0x00000449 => "\xf9",
     0x0000044a => "\xfa",
     0x0000044b => "\xfb",
     0x0000044c => "\xfc",
     0x0000044d => "\xfd",
     0x0000044e => "\xfe",
     0x0000044f => "\xdf",
     0x00000451 => "\xde",
     0x00000452 => "\xac",
     0x00000453 => "\xaf",
     0x00000454 => "\xb9",
     0x00000455 => "\xcf",
     0x00000456 => "\xb4",
     0x00000457 => "\xbb",
     0x00000458 => "\xc0",
     0x00000459 => "\xbd",
     0x0000045a => "\xbf",
     0x0000045b => "\xcc",
     0x0000045c => "\xce",
     0x0000045e => "\xd9",
     0x0000045f => "\xdb",
     0x00000491 => "\xb6",
     0x00002013 => "\xd0",
     0x00002014 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xd7",
     0x00002020 => "\xa0",
     0x00002022 => "\xa5",
     0x00002026 => "\xc9",
     0x00002116 => "\xdc",
     0x00002122 => "\xaa",
     0x00002206 => "\xc6",
     0x0000221a => "\xc3",
     0x0000221e => "\xb0",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x00002264 => "\xb2",
     0x00002265 => "\xb3",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/CP1250.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::CP1250;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x20ac,
     0xfffd,
     0x201a,
     0xfffd,
     0x201e,
     0x2026,
     0x2020,
     0x2021,
     0xfffd,
     0x2030,
     0x0160,
     0x2039,
     0x015a,
     0x0164,
     0x017d,
     0x0179,
     0xfffd,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0xfffd,
     0x2122,
     0x0161,
     0x203a,
     0x015b,
     0x0165,
     0x017e,
     0x017a,
     0x00a0,
     0x02c7,
     0x02d8,
     0x0141,
     0x00a4,
     0x0104,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0x015e,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x017b,
     0x00b0,
     0x00b1,
     0x02db,
     0x0142,
     0x00b4,
     0x00b5,
     0x00b6,
     0x00b7,
     0x00b8,
     0x0105,
     0x015f,
     0x00bb,
     0x013d,
     0x02dd,
     0x013e,
     0x017c,
     0x0154,
     0x00c1,
     0x00c2,
     0x0102,
     0x00c4,
     0x0139,
     0x0106,
     0x00c7,
     0x010c,
     0x00c9,
     0x0118,
     0x00cb,
     0x011a,
     0x00cd,
     0x00ce,
     0x010e,
     0x0110,
     0x0143,
     0x0147,
     0x00d3,
     0x00d4,
     0x0150,
     0x00d6,
     0x00d7,
     0x0158,
     0x016e,
     0x00da,
     0x0170,
     0x00dc,
     0x00dd,
     0x0162,
     0x00df,
     0x0155,
     0x00e1,
     0x00e2,
     0x0103,
     0x00e4,
     0x013a,
     0x0107,
     0x00e7,
     0x010d,
     0x00e9,
     0x0119,
     0x00eb,
     0x011b,
     0x00ed,
     0x00ee,
     0x010f,
     0x0111,
     0x0144,
     0x0148,
     0x00f3,
     0x00f4,
     0x0151,
     0x00f6,
     0x00f7,
     0x0159,
     0x016f,
     0x00fa,
     0x0171,
     0x00fc,
     0x00fd,
     0x0163,
     0x02d9,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe2\x82\xac",
     "\xef\xbf\xbd",
     "\xe2\x80\x9a",
     "\xef\xbf\xbd",
     "\xe2\x80\x9e",
     "\xe2\x80\xa6",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xef\xbf\xbd",
     "\xe2\x80\xb0",
     "\xc5\xa0",
     "\xe2\x80\xb9",
     "\xc5\x9a",
     "\xc5\xa4",
     "\xc5\xbd",
     "\xc5\xb9",
     "\xef\xbf\xbd",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xef\xbf\xbd",
     "\xe2\x84\xa2",
     "\xc5\xa1",
     "\xe2\x80\xba",
     "\xc5\x9b",
     "\xc5\xa5",
     "\xc5\xbe",
     "\xc5\xba",
     "\xc2\xa0",
     "\xcb\x87",
     "\xcb\x98",
     "\xc5\x81",
     "\xc2\xa4",
     "\xc4\x84",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xc5\x9e",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc5\xbb",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xcb\x9b",
     "\xc5\x82",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc2\xb8",
     "\xc4\x85",
     "\xc5\x9f",
     "\xc2\xbb",
     "\xc4\xbd",
     "\xcb\x9d",
     "\xc4\xbe",
     "\xc5\xbc",
     "\xc5\x94",
     "\xc3\x81",
     "\xc3\x82",
     "\xc4\x82",
     "\xc3\x84",
     "\xc4\xb9",
     "\xc4\x86",
     "\xc3\x87",
     "\xc4\x8c",
     "\xc3\x89",
     "\xc4\x98",
     "\xc3\x8b",
     "\xc4\x9a",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc4\x8e",
     "\xc4\x90",
     "\xc5\x83",
     "\xc5\x87",
     "\xc3\x93",
     "\xc3\x94",
     "\xc5\x90",
     "\xc3\x96",
     "\xc3\x97",
     "\xc5\x98",
     "\xc5\xae",
     "\xc3\x9a",
     "\xc5\xb0",
     "\xc3\x9c",
     "\xc3\x9d",
     "\xc5\xa2",
     "\xc3\x9f",
     "\xc5\x95",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc4\x83",
     "\xc3\xa4",
     "\xc4\xba",
     "\xc4\x87",
     "\xc3\xa7",
     "\xc4\x8d",
     "\xc3\xa9",
     "\xc4\x99",
     "\xc3\xab",
     "\xc4\x9b",
     "\xc3\xad",
     "\xc3\xae",
     "\xc4\x8f",
     "\xc4\x91",
     "\xc5\x84",
     "\xc5\x88",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc5\x91",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc5\x99",
     "\xc5\xaf",
     "\xc3\xba",
     "\xc5\xb1",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc5\xa3",
     "\xcb\x99",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x000000a4 => "\xa4",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b8 => "\xb8",
     0x000000bb => "\xbb",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c4 => "\xc4",
     0x000000c7 => "\xc7",
     0x000000c9 => "\xc9",
     0x000000cb => "\xcb",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000da => "\xda",
     0x000000dc => "\xdc",
     0x000000dd => "\xdd",
     0x000000df => "\xdf",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e4 => "\xe4",
     0x000000e7 => "\xe7",
     0x000000e9 => "\xe9",
     0x000000eb => "\xeb",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000fa => "\xfa",
     0x000000fc => "\xfc",
     0x000000fd => "\xfd",
     0x00000102 => "\xc3",
     0x00000103 => "\xe3",
     0x00000104 => "\xa5",
     0x00000105 => "\xb9",
     0x00000106 => "\xc6",
     0x00000107 => "\xe6",
     0x0000010c => "\xc8",
     0x0000010d => "\xe8",
     0x0000010e => "\xcf",
     0x0000010f => "\xef",
     0x00000110 => "\xd0",
     0x00000111 => "\xf0",
     0x00000118 => "\xca",
     0x00000119 => "\xea",
     0x0000011a => "\xcc",
     0x0000011b => "\xec",
     0x00000139 => "\xc5",
     0x0000013a => "\xe5",
     0x0000013d => "\xbc",
     0x0000013e => "\xbe",
     0x00000141 => "\xa3",
     0x00000142 => "\xb3",
     0x00000143 => "\xd1",
     0x00000144 => "\xf1",
     0x00000147 => "\xd2",
     0x00000148 => "\xf2",
     0x00000150 => "\xd5",
     0x00000151 => "\xf5",
     0x00000154 => "\xc0",
     0x00000155 => "\xe0",
     0x00000158 => "\xd8",
     0x00000159 => "\xf8",
     0x0000015a => "\x8c",
     0x0000015b => "\x9c",
     0x0000015e => "\xaa",
     0x0000015f => "\xba",
     0x00000160 => "\x8a",
     0x00000161 => "\x9a",
     0x00000162 => "\xde",
     0x00000163 => "\xfe",
     0x00000164 => "\x8d",
     0x00000165 => "\x9d",
     0x0000016e => "\xd9",
     0x0000016f => "\xf9",
     0x00000170 => "\xdb",
     0x00000171 => "\xfb",
     0x00000179 => "\x8f",
     0x0000017a => "\x9f",
     0x0000017b => "\xaf",
     0x0000017c => "\xbf",
     0x0000017d => "\x8e",
     0x0000017e => "\x9e",
     0x000002c7 => "\xa1",
     0x000002d8 => "\xa2",
     0x000002d9 => "\xff",
     0x000002db => "\xb2",
     0x000002dd => "\xbd",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201a => "\x82",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x0000201e => "\x84",
     0x00002020 => "\x86",
     0x00002021 => "\x87",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x00002030 => "\x89",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x000020ac => "\x80",
     0x00002122 => "\x99",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/CP1251.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::CP1251;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0402,
     0x0403,
     0x201a,
     0x0453,
     0x201e,
     0x2026,
     0x2020,
     0x2021,
     0x20ac,
     0x2030,
     0x0409,
     0x2039,
     0x040a,
     0x040c,
     0x040b,
     0x040f,
     0x0452,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0xfffd,
     0x2122,
     0x0459,
     0x203a,
     0x045a,
     0x045c,
     0x045b,
     0x045f,
     0x00a0,
     0x040e,
     0x045e,
     0x0408,
     0x00a4,
     0x0490,
     0x00a6,
     0x00a7,
     0x0401,
     0x00a9,
     0x0404,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x0407,
     0x00b0,
     0x00b1,
     0x0406,
     0x0456,
     0x0491,
     0x00b5,
     0x00b6,
     0x00b7,
     0x0451,
     0x2116,
     0x0454,
     0x00bb,
     0x0458,
     0x0405,
     0x0455,
     0x0457,
     0x0410,
     0x0411,
     0x0412,
     0x0413,
     0x0414,
     0x0415,
     0x0416,
     0x0417,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0424,
     0x0425,
     0x0426,
     0x0427,
     0x0428,
     0x0429,
     0x042a,
     0x042b,
     0x042c,
     0x042d,
     0x042e,
     0x042f,
     0x0430,
     0x0431,
     0x0432,
     0x0433,
     0x0434,
     0x0435,
     0x0436,
     0x0437,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0444,
     0x0445,
     0x0446,
     0x0447,
     0x0448,
     0x0449,
     0x044a,
     0x044b,
     0x044c,
     0x044d,
     0x044e,
     0x044f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xd0\x82",
     "\xd0\x83",
     "\xe2\x80\x9a",
     "\xd1\x93",
     "\xe2\x80\x9e",
     "\xe2\x80\xa6",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xe2\x82\xac",
     "\xe2\x80\xb0",
     "\xd0\x89",
     "\xe2\x80\xb9",
     "\xd0\x8a",
     "\xd0\x8c",
     "\xd0\x8b",
     "\xd0\x8f",
     "\xd1\x92",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xef\xbf\xbd",
     "\xe2\x84\xa2",
     "\xd1\x99",
     "\xe2\x80\xba",
     "\xd1\x9a",
     "\xd1\x9c",
     "\xd1\x9b",
     "\xd1\x9f",
     "\xc2\xa0",
     "\xd0\x8e",
     "\xd1\x9e",
     "\xd0\x88",
     "\xc2\xa4",
     "\xd2\x90",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xd0\x81",
     "\xc2\xa9",
     "\xd0\x84",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xd0\x87",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xd0\x86",
     "\xd1\x96",
     "\xd2\x91",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xd1\x91",
     "\xe2\x84\x96",
     "\xd1\x94",
     "\xc2\xbb",
     "\xd1\x98",
     "\xd0\x85",
     "\xd1\x95",
     "\xd1\x97",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\x92",
     "\xd0\x93",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\x96",
     "\xd0\x97",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\xa4",
     "\xd0\xa5",
     "\xd0\xa6",
     "\xd0\xa7",
     "\xd0\xa8",
     "\xd0\xa9",
     "\xd0\xaa",
     "\xd0\xab",
     "\xd0\xac",
     "\xd0\xad",
     "\xd0\xae",
     "\xd0\xaf",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd0\xb2",
     "\xd0\xb3",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd0\xb6",
     "\xd0\xb7",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd1\x84",
     "\xd1\x85",
     "\xd1\x86",
     "\xd1\x87",
     "\xd1\x88",
     "\xd1\x89",
     "\xd1\x8a",
     "\xd1\x8b",
     "\xd1\x8c",
     "\xd1\x8d",
     "\xd1\x8e",
     "\xd1\x8f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x000000a4 => "\xa4",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a9 => "\xa9",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000bb => "\xbb",
     0x00000401 => "\xa8",
     0x00000402 => "\x80",
     0x00000403 => "\x81",
     0x00000404 => "\xaa",
     0x00000405 => "\xbd",
     0x00000406 => "\xb2",
     0x00000407 => "\xaf",
     0x00000408 => "\xa3",
     0x00000409 => "\x8a",
     0x0000040a => "\x8c",
     0x0000040b => "\x8e",
     0x0000040c => "\x8d",
     0x0000040e => "\xa1",
     0x0000040f => "\x8f",
     0x00000410 => "\xc0",
     0x00000411 => "\xc1",
     0x00000412 => "\xc2",
     0x00000413 => "\xc3",
     0x00000414 => "\xc4",
     0x00000415 => "\xc5",
     0x00000416 => "\xc6",
     0x00000417 => "\xc7",
     0x00000418 => "\xc8",
     0x00000419 => "\xc9",
     0x0000041a => "\xca",
     0x0000041b => "\xcb",
     0x0000041c => "\xcc",
     0x0000041d => "\xcd",
     0x0000041e => "\xce",
     0x0000041f => "\xcf",
     0x00000420 => "\xd0",
     0x00000421 => "\xd1",
     0x00000422 => "\xd2",
     0x00000423 => "\xd3",
     0x00000424 => "\xd4",
     0x00000425 => "\xd5",
     0x00000426 => "\xd6",
     0x00000427 => "\xd7",
     0x00000428 => "\xd8",
     0x00000429 => "\xd9",
     0x0000042a => "\xda",
     0x0000042b => "\xdb",
     0x0000042c => "\xdc",
     0x0000042d => "\xdd",
     0x0000042e => "\xde",
     0x0000042f => "\xdf",
     0x00000430 => "\xe0",
     0x00000431 => "\xe1",
     0x00000432 => "\xe2",
     0x00000433 => "\xe3",
     0x00000434 => "\xe4",
     0x00000435 => "\xe5",
     0x00000436 => "\xe6",
     0x00000437 => "\xe7",
     0x00000438 => "\xe8",
     0x00000439 => "\xe9",
     0x0000043a => "\xea",
     0x0000043b => "\xeb",
     0x0000043c => "\xec",
     0x0000043d => "\xed",
     0x0000043e => "\xee",
     0x0000043f => "\xef",
     0x00000440 => "\xf0",
     0x00000441 => "\xf1",
     0x00000442 => "\xf2",
     0x00000443 => "\xf3",
     0x00000444 => "\xf4",
     0x00000445 => "\xf5",
     0x00000446 => "\xf6",
     0x00000447 => "\xf7",
     0x00000448 => "\xf8",
     0x00000449 => "\xf9",
     0x0000044a => "\xfa",
     0x0000044b => "\xfb",
     0x0000044c => "\xfc",
     0x0000044d => "\xfd",
     0x0000044e => "\xfe",
     0x0000044f => "\xff",
     0x00000451 => "\xb8",
     0x00000452 => "\x90",
     0x00000453 => "\x83",
     0x00000454 => "\xba",
     0x00000455 => "\xbe",
     0x00000456 => "\xb3",
     0x00000457 => "\xbf",
     0x00000458 => "\xbc",
     0x00000459 => "\x9a",
     0x0000045a => "\x9c",
     0x0000045b => "\x9e",
     0x0000045c => "\x9d",
     0x0000045e => "\xa2",
     0x0000045f => "\x9f",
     0x00000490 => "\xa5",
     0x00000491 => "\xb4",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201a => "\x82",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x0000201e => "\x84",
     0x00002020 => "\x86",
     0x00002021 => "\x87",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x00002030 => "\x89",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x000020ac => "\x88",
     0x00002116 => "\xb9",
     0x00002122 => "\x99",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/CP1252.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::CP1252;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x20ac,
     0xfffd,
     0x201a,
     0x0192,
     0x201e,
     0x2026,
     0x2020,
     0x2021,
     0x02c6,
     0x2030,
     0x0160,
     0x2039,
     0x0152,
     0xfffd,
     0x017d,
     0xfffd,
     0xfffd,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0x02dc,
     0x2122,
     0x0161,
     0x203a,
     0x0153,
     0xfffd,
     0x017e,
     0x0178,
     0x00a0,
     0x00a1,
     0x00a2,
     0x00a3,
     0x00a4,
     0x00a5,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0x00aa,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x00af,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x00b4,
     0x00b5,
     0x00b6,
     0x00b7,
     0x00b8,
     0x00b9,
     0x00ba,
     0x00bb,
     0x00bc,
     0x00bd,
     0x00be,
     0x00bf,
     0x00c0,
     0x00c1,
     0x00c2,
     0x00c3,
     0x00c4,
     0x00c5,
     0x00c6,
     0x00c7,
     0x00c8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00cc,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00d0,
     0x00d1,
     0x00d2,
     0x00d3,
     0x00d4,
     0x00d5,
     0x00d6,
     0x00d7,
     0x00d8,
     0x00d9,
     0x00da,
     0x00db,
     0x00dc,
     0x00dd,
     0x00de,
     0x00df,
     0x00e0,
     0x00e1,
     0x00e2,
     0x00e3,
     0x00e4,
     0x00e5,
     0x00e6,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00f0,
     0x00f1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x00f7,
     0x00f8,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x00fd,
     0x00fe,
     0x00ff,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe2\x82\xac",
     "\xef\xbf\xbd",
     "\xe2\x80\x9a",
     "\xc6\x92",
     "\xe2\x80\x9e",
     "\xe2\x80\xa6",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xcb\x86",
     "\xe2\x80\xb0",
     "\xc5\xa0",
     "\xe2\x80\xb9",
     "\xc5\x92",
     "\xef\xbf\xbd",
     "\xc5\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xcb\x9c",
     "\xe2\x84\xa2",
     "\xc5\xa1",
     "\xe2\x80\xba",
     "\xc5\x93",
     "\xef\xbf\xbd",
     "\xc5\xbe",
     "\xc5\xb8",
     "\xc2\xa0",
     "\xc2\xa1",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xc2\xa5",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xc2\xaa",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc2\xaf",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc2\xb8",
     "\xc2\xb9",
     "\xc2\xba",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xbf",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x86",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x90",
     "\xc3\x91",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xc3\x97",
     "\xc3\x98",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc3\x9f",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb0",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc3\xb8",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc3\xbf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x000000a1 => "\xa1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a5 => "\xa5",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000aa => "\xaa",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000af => "\xaf",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b8 => "\xb8",
     0x000000b9 => "\xb9",
     0x000000ba => "\xba",
     0x000000bb => "\xbb",
     0x000000bc => "\xbc",
     0x000000bd => "\xbd",
     0x000000be => "\xbe",
     0x000000bf => "\xbf",
     0x000000c0 => "\xc0",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c3 => "\xc3",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xc6",
     0x000000c7 => "\xc7",
     0x000000c8 => "\xc8",
     0x000000c9 => "\xc9",
     0x000000ca => "\xca",
     0x000000cb => "\xcb",
     0x000000cc => "\xcc",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000cf => "\xcf",
     0x000000d0 => "\xd0",
     0x000000d1 => "\xd1",
     0x000000d2 => "\xd2",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000d8 => "\xd8",
     0x000000d9 => "\xd9",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000dd => "\xdd",
     0x000000de => "\xde",
     0x000000df => "\xdf",
     0x000000e0 => "\xe0",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e3 => "\xe3",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xe6",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f0 => "\xf0",
     0x000000f1 => "\xf1",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f8 => "\xf8",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000fd => "\xfd",
     0x000000fe => "\xfe",
     0x000000ff => "\xff",
     0x00000152 => "\x8c",
     0x00000153 => "\x9c",
     0x00000160 => "\x8a",
     0x00000161 => "\x9a",
     0x00000178 => "\x9f",
     0x0000017d => "\x8e",
     0x0000017e => "\x9e",
     0x00000192 => "\x83",
     0x000002c6 => "\x88",
     0x000002dc => "\x98",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201a => "\x82",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x0000201e => "\x84",
     0x00002020 => "\x86",
     0x00002021 => "\x87",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x00002030 => "\x89",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x000020ac => "\x80",
     0x00002122 => "\x99",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/CP1253.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::CP1253;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x20ac,
     0xfffd,
     0x201a,
     0x0192,
     0x201e,
     0x2026,
     0x2020,
     0x2021,
     0xfffd,
     0x2030,
     0xfffd,
     0x2039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0xfffd,
     0x2122,
     0xfffd,
     0x203a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a0,
     0x0385,
     0x0386,
     0x00a3,
     0x00a4,
     0x00a5,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0xfffd,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x2015,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x0384,
     0x00b5,
     0x00b6,
     0x00b7,
     0x0388,
     0x0389,
     0x038a,
     0x00bb,
     0x038c,
     0x00bd,
     0x038e,
     0x038f,
     0x0390,
     0x0391,
     0x0392,
     0x0393,
     0x0394,
     0x0395,
     0x0396,
     0x0397,
     0x0398,
     0x0399,
     0x039a,
     0x039b,
     0x039c,
     0x039d,
     0x039e,
     0x039f,
     0x03a0,
     0x03a1,
     0xfffd,
     0x03a3,
     0x03a4,
     0x03a5,
     0x03a6,
     0x03a7,
     0x03a8,
     0x03a9,
     0x03aa,
     0x03ab,
     0x03ac,
     0x03ad,
     0x03ae,
     0x03af,
     0x03b0,
     0x03b1,
     0x03b2,
     0x03b3,
     0x03b4,
     0x03b5,
     0x03b6,
     0x03b7,
     0x03b8,
     0x03b9,
     0x03ba,
     0x03bb,
     0x03bc,
     0x03bd,
     0x03be,
     0x03bf,
     0x03c0,
     0x03c1,
     0x03c2,
     0x03c3,
     0x03c4,
     0x03c5,
     0x03c6,
     0x03c7,
     0x03c8,
     0x03c9,
     0x03ca,
     0x03cb,
     0x03cc,
     0x03cd,
     0x03ce,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe2\x82\xac",
     "\xef\xbf\xbd",
     "\xe2\x80\x9a",
     "\xc6\x92",
     "\xe2\x80\x9e",
     "\xe2\x80\xa6",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xef\xbf\xbd",
     "\xe2\x80\xb0",
     "\xef\xbf\xbd",
     "\xe2\x80\xb9",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xef\xbf\xbd",
     "\xe2\x84\xa2",
     "\xef\xbf\xbd",
     "\xe2\x80\xba",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa0",
     "\xce\x85",
     "\xce\x86",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xc2\xa5",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xef\xbf\xbd",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xe2\x80\x95",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xce\x84",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xce\x88",
     "\xce\x89",
     "\xce\x8a",
     "\xc2\xbb",
     "\xce\x8c",
     "\xc2\xbd",
     "\xce\x8e",
     "\xce\x8f",
     "\xce\x90",
     "\xce\x91",
     "\xce\x92",
     "\xce\x93",
     "\xce\x94",
     "\xce\x95",
     "\xce\x96",
     "\xce\x97",
     "\xce\x98",
     "\xce\x99",
     "\xce\x9a",
     "\xce\x9b",
     "\xce\x9c",
     "\xce\x9d",
     "\xce\x9e",
     "\xce\x9f",
     "\xce\xa0",
     "\xce\xa1",
     "\xef\xbf\xbd",
     "\xce\xa3",
     "\xce\xa4",
     "\xce\xa5",
     "\xce\xa6",
     "\xce\xa7",
     "\xce\xa8",
     "\xce\xa9",
     "\xce\xaa",
     "\xce\xab",
     "\xce\xac",
     "\xce\xad",
     "\xce\xae",
     "\xce\xaf",
     "\xce\xb0",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\xb3",
     "\xce\xb4",
     "\xce\xb5",
     "\xce\xb6",
     "\xce\xb7",
     "\xce\xb8",
     "\xce\xb9",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xce\xbd",
     "\xce\xbe",
     "\xce\xbf",
     "\xcf\x80",
     "\xcf\x81",
     "\xcf\x82",
     "\xcf\x83",
     "\xcf\x84",
     "\xcf\x85",
     "\xcf\x86",
     "\xcf\x87",
     "\xcf\x88",
     "\xcf\x89",
     "\xcf\x8a",
     "\xcf\x8b",
     "\xcf\x8c",
     "\xcf\x8d",
     "\xcf\x8e",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a5 => "\xa5",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000bb => "\xbb",
     0x000000bd => "\xbd",
     0x00000192 => "\x83",
     0x00000384 => "\xb4",
     0x00000385 => "\xa1",
     0x00000386 => "\xa2",
     0x00000388 => "\xb8",
     0x00000389 => "\xb9",
     0x0000038a => "\xba",
     0x0000038c => "\xbc",
     0x0000038e => "\xbe",
     0x0000038f => "\xbf",
     0x00000390 => "\xc0",
     0x00000391 => "\xc1",
     0x00000392 => "\xc2",
     0x00000393 => "\xc3",
     0x00000394 => "\xc4",
     0x00000395 => "\xc5",
     0x00000396 => "\xc6",
     0x00000397 => "\xc7",
     0x00000398 => "\xc8",
     0x00000399 => "\xc9",
     0x0000039a => "\xca",
     0x0000039b => "\xcb",
     0x0000039c => "\xcc",
     0x0000039d => "\xcd",
     0x0000039e => "\xce",
     0x0000039f => "\xcf",
     0x000003a0 => "\xd0",
     0x000003a1 => "\xd1",
     0x000003a3 => "\xd3",
     0x000003a4 => "\xd4",
     0x000003a5 => "\xd5",
     0x000003a6 => "\xd6",
     0x000003a7 => "\xd7",
     0x000003a8 => "\xd8",
     0x000003a9 => "\xd9",
     0x000003aa => "\xda",
     0x000003ab => "\xdb",
     0x000003ac => "\xdc",
     0x000003ad => "\xdd",
     0x000003ae => "\xde",
     0x000003af => "\xdf",
     0x000003b0 => "\xe0",
     0x000003b1 => "\xe1",
     0x000003b2 => "\xe2",
     0x000003b3 => "\xe3",
     0x000003b4 => "\xe4",
     0x000003b5 => "\xe5",
     0x000003b6 => "\xe6",
     0x000003b7 => "\xe7",
     0x000003b8 => "\xe8",
     0x000003b9 => "\xe9",
     0x000003ba => "\xea",
     0x000003bb => "\xeb",
     0x000003bc => "\xec",
     0x000003bd => "\xed",
     0x000003be => "\xee",
     0x000003bf => "\xef",
     0x000003c0 => "\xf0",
     0x000003c1 => "\xf1",
     0x000003c2 => "\xf2",
     0x000003c3 => "\xf3",
     0x000003c4 => "\xf4",
     0x000003c5 => "\xf5",
     0x000003c6 => "\xf6",
     0x000003c7 => "\xf7",
     0x000003c8 => "\xf8",
     0x000003c9 => "\xf9",
     0x000003ca => "\xfa",
     0x000003cb => "\xfb",
     0x000003cc => "\xfc",
     0x000003cd => "\xfd",
     0x000003ce => "\xfe",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002015 => "\xaf",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201a => "\x82",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x0000201e => "\x84",
     0x00002020 => "\x86",
     0x00002021 => "\x87",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x00002030 => "\x89",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x000020ac => "\x80",
     0x00002122 => "\x99",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/CP1254.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::CP1254;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x20ac,
     0xfffd,
     0x201a,
     0x0192,
     0x201e,
     0x2026,
     0x2020,
     0x2021,
     0x02c6,
     0x2030,
     0x0160,
     0x2039,
     0x0152,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0x02dc,
     0x2122,
     0x0161,
     0x203a,
     0x0153,
     0xfffd,
     0xfffd,
     0x0178,
     0x00a0,
     0x00a1,
     0x00a2,
     0x00a3,
     0x00a4,
     0x00a5,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0x00aa,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x00af,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x00b4,
     0x00b5,
     0x00b6,
     0x00b7,
     0x00b8,
     0x00b9,
     0x00ba,
     0x00bb,
     0x00bc,
     0x00bd,
     0x00be,
     0x00bf,
     0x00c0,
     0x00c1,
     0x00c2,
     0x00c3,
     0x00c4,
     0x00c5,
     0x00c6,
     0x00c7,
     0x00c8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00cc,
     0x00cd,
     0x00ce,
     0x00cf,
     0x011e,
     0x00d1,
     0x00d2,
     0x00d3,
     0x00d4,
     0x00d5,
     0x00d6,
     0x00d7,
     0x00d8,
     0x00d9,
     0x00da,
     0x00db,
     0x00dc,
     0x0130,
     0x015e,
     0x00df,
     0x00e0,
     0x00e1,
     0x00e2,
     0x00e3,
     0x00e4,
     0x00e5,
     0x00e6,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0x011f,
     0x00f1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x00f7,
     0x00f8,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x0131,
     0x015f,
     0x00ff,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe2\x82\xac",
     "\xef\xbf\xbd",
     "\xe2\x80\x9a",
     "\xc6\x92",
     "\xe2\x80\x9e",
     "\xe2\x80\xa6",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xcb\x86",
     "\xe2\x80\xb0",
     "\xc5\xa0",
     "\xe2\x80\xb9",
     "\xc5\x92",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xcb\x9c",
     "\xe2\x84\xa2",
     "\xc5\xa1",
     "\xe2\x80\xba",
     "\xc5\x93",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc5\xb8",
     "\xc2\xa0",
     "\xc2\xa1",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xc2\xa5",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xc2\xaa",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc2\xaf",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc2\xb8",
     "\xc2\xb9",
     "\xc2\xba",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xbf",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x86",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc4\x9e",
     "\xc3\x91",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xc3\x97",
     "\xc3\x98",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc4\xb0",
     "\xc5\x9e",
     "\xc3\x9f",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc4\x9f",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc3\xb8",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc4\xb1",
     "\xc5\x9f",
     "\xc3\xbf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x000000a1 => "\xa1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a5 => "\xa5",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000aa => "\xaa",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000af => "\xaf",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b8 => "\xb8",
     0x000000b9 => "\xb9",
     0x000000ba => "\xba",
     0x000000bb => "\xbb",
     0x000000bc => "\xbc",
     0x000000bd => "\xbd",
     0x000000be => "\xbe",
     0x000000bf => "\xbf",
     0x000000c0 => "\xc0",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c3 => "\xc3",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xc6",
     0x000000c7 => "\xc7",
     0x000000c8 => "\xc8",
     0x000000c9 => "\xc9",
     0x000000ca => "\xca",
     0x000000cb => "\xcb",
     0x000000cc => "\xcc",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000cf => "\xcf",
     0x000000d1 => "\xd1",
     0x000000d2 => "\xd2",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000d8 => "\xd8",
     0x000000d9 => "\xd9",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000df => "\xdf",
     0x000000e0 => "\xe0",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e3 => "\xe3",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xe6",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f1 => "\xf1",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f8 => "\xf8",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000ff => "\xff",
     0x0000011e => "\xd0",
     0x0000011f => "\xf0",
     0x00000130 => "\xdd",
     0x00000131 => "\xfd",
     0x00000152 => "\x8c",
     0x00000153 => "\x9c",
     0x0000015e => "\xde",
     0x0000015f => "\xfe",
     0x00000160 => "\x8a",
     0x00000161 => "\x9a",
     0x00000178 => "\x9f",
     0x00000192 => "\x83",
     0x000002c6 => "\x88",
     0x000002dc => "\x98",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201a => "\x82",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x0000201e => "\x84",
     0x00002020 => "\x86",
     0x00002021 => "\x87",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x00002030 => "\x89",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x000020ac => "\x80",
     0x00002122 => "\x99",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/CP1256.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::CP1256;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x20ac,
     0x067e,
     0x201a,
     0x0192,
     0x201e,
     0x2026,
     0x2020,
     0x2021,
     0x02c6,
     0x2030,
     0x0679,
     0x2039,
     0x0152,
     0x0686,
     0x0698,
     0x0688,
     0x06af,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0x06a9,
     0x2122,
     0x0691,
     0x203a,
     0x0153,
     0x200c,
     0x200d,
     0x06ba,
     0x00a0,
     0x060c,
     0x00a2,
     0x00a3,
     0x00a4,
     0x00a5,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0x06be,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x00af,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x00b4,
     0x00b5,
     0x00b6,
     0x00b7,
     0x00b8,
     0x00b9,
     0x061b,
     0x00bb,
     0x00bc,
     0x00bd,
     0x00be,
     0x061f,
     0x06c1,
     0x0621,
     0x0622,
     0x0623,
     0x0624,
     0x0625,
     0x0626,
     0x0627,
     0x0628,
     0x0629,
     0x062a,
     0x062b,
     0x062c,
     0x062d,
     0x062e,
     0x062f,
     0x0630,
     0x0631,
     0x0632,
     0x0633,
     0x0634,
     0x0635,
     0x0636,
     0x00d7,
     0x0637,
     0x0638,
     0x0639,
     0x063a,
     0x0640,
     0x0641,
     0x0642,
     0x0643,
     0x00e0,
     0x0644,
     0x00e2,
     0x0645,
     0x0646,
     0x0647,
     0x0648,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x0649,
     0x064a,
     0x00ee,
     0x00ef,
     0x064b,
     0x064c,
     0x064d,
     0x064e,
     0x00f4,
     0x064f,
     0x0650,
     0x00f7,
     0x0651,
     0x00f9,
     0x0652,
     0x00fb,
     0x00fc,
     0x200e,
     0x200f,
     0x06d2,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe2\x82\xac",
     "\xd9\xbe",
     "\xe2\x80\x9a",
     "\xc6\x92",
     "\xe2\x80\x9e",
     "\xe2\x80\xa6",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xcb\x86",
     "\xe2\x80\xb0",
     "\xd9\xb9",
     "\xe2\x80\xb9",
     "\xc5\x92",
     "\xda\x86",
     "\xda\x98",
     "\xda\x88",
     "\xda\xaf",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xda\xa9",
     "\xe2\x84\xa2",
     "\xda\x91",
     "\xe2\x80\xba",
     "\xc5\x93",
     "\xe2\x80\x8c",
     "\xe2\x80\x8d",
     "\xda\xba",
     "\xc2\xa0",
     "\xd8\x8c",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xc2\xa5",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xda\xbe",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc2\xaf",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc2\xb8",
     "\xc2\xb9",
     "\xd8\x9b",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xd8\x9f",
     "\xdb\x81",
     "\xd8\xa1",
     "\xd8\xa2",
     "\xd8\xa3",
     "\xd8\xa4",
     "\xd8\xa5",
     "\xd8\xa6",
     "\xd8\xa7",
     "\xd8\xa8",
     "\xd8\xa9",
     "\xd8\xaa",
     "\xd8\xab",
     "\xd8\xac",
     "\xd8\xad",
     "\xd8\xae",
     "\xd8\xaf",
     "\xd8\xb0",
     "\xd8\xb1",
     "\xd8\xb2",
     "\xd8\xb3",
     "\xd8\xb4",
     "\xd8\xb5",
     "\xd8\xb6",
     "\xc3\x97",
     "\xd8\xb7",
     "\xd8\xb8",
     "\xd8\xb9",
     "\xd8\xba",
     "\xd9\x80",
     "\xd9\x81",
     "\xd9\x82",
     "\xd9\x83",
     "\xc3\xa0",
     "\xd9\x84",
     "\xc3\xa2",
     "\xd9\x85",
     "\xd9\x86",
     "\xd9\x87",
     "\xd9\x88",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xd9\x89",
     "\xd9\x8a",
     "\xc3\xae",
     "\xc3\xaf",
     "\xd9\x8b",
     "\xd9\x8c",
     "\xd9\x8d",
     "\xd9\x8e",
     "\xc3\xb4",
     "\xd9\x8f",
     "\xd9\x90",
     "\xc3\xb7",
     "\xd9\x91",
     "\xc3\xb9",
     "\xd9\x92",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xe2\x80\x8e",
     "\xe2\x80\x8f",
     "\xdb\x92",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a5 => "\xa5",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000af => "\xaf",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b8 => "\xb8",
     0x000000b9 => "\xb9",
     0x000000bb => "\xbb",
     0x000000bc => "\xbc",
     0x000000bd => "\xbd",
     0x000000be => "\xbe",
     0x000000d7 => "\xd7",
     0x000000e0 => "\xe0",
     0x000000e2 => "\xe2",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f4 => "\xf4",
     0x000000f7 => "\xf7",
     0x000000f9 => "\xf9",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x00000152 => "\x8c",
     0x00000153 => "\x9c",
     0x00000192 => "\x83",
     0x000002c6 => "\x88",
     0x0000060c => "\xa1",
     0x0000061b => "\xba",
     0x0000061f => "\xbf",
     0x00000621 => "\xc1",
     0x00000622 => "\xc2",
     0x00000623 => "\xc3",
     0x00000624 => "\xc4",
     0x00000625 => "\xc5",
     0x00000626 => "\xc6",
     0x00000627 => "\xc7",
     0x00000628 => "\xc8",
     0x00000629 => "\xc9",
     0x0000062a => "\xca",
     0x0000062b => "\xcb",
     0x0000062c => "\xcc",
     0x0000062d => "\xcd",
     0x0000062e => "\xce",
     0x0000062f => "\xcf",
     0x00000630 => "\xd0",
     0x00000631 => "\xd1",
     0x00000632 => "\xd2",
     0x00000633 => "\xd3",
     0x00000634 => "\xd4",
     0x00000635 => "\xd5",
     0x00000636 => "\xd6",
     0x00000637 => "\xd8",
     0x00000638 => "\xd9",
     0x00000639 => "\xda",
     0x0000063a => "\xdb",
     0x00000640 => "\xdc",
     0x00000641 => "\xdd",
     0x00000642 => "\xde",
     0x00000643 => "\xdf",
     0x00000644 => "\xe1",
     0x00000645 => "\xe3",
     0x00000646 => "\xe4",
     0x00000647 => "\xe5",
     0x00000648 => "\xe6",
     0x00000649 => "\xec",
     0x0000064a => "\xed",
     0x0000064b => "\xf0",
     0x0000064c => "\xf1",
     0x0000064d => "\xf2",
     0x0000064e => "\xf3",
     0x0000064f => "\xf5",
     0x00000650 => "\xf6",
     0x00000651 => "\xf8",
     0x00000652 => "\xfa",
     0x00000679 => "\x8a",
     0x0000067e => "\x81",
     0x00000686 => "\x8d",
     0x00000688 => "\x8f",
     0x00000691 => "\x9a",
     0x00000698 => "\x8e",
     0x000006a9 => "\x98",
     0x000006af => "\x90",
     0x000006ba => "\x9f",
     0x000006be => "\xaa",
     0x000006c1 => "\xc0",
     0x000006d2 => "\xff",
     0x0000200c => "\x9d",
     0x0000200d => "\x9e",
     0x0000200e => "\xfd",
     0x0000200f => "\xfe",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201a => "\x82",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x0000201e => "\x84",
     0x00002020 => "\x86",
     0x00002021 => "\x87",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x00002030 => "\x89",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x000020ac => "\x80",
     0x00002122 => "\x99",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/CP1257.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::CP1257;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x20ac,
     0xfffd,
     0x201a,
     0xfffd,
     0x201e,
     0x2026,
     0x2020,
     0x2021,
     0xfffd,
     0x2030,
     0xfffd,
     0x2039,
     0xfffd,
     0x00a8,
     0x02c7,
     0x00b8,
     0xfffd,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0xfffd,
     0x2122,
     0xfffd,
     0x203a,
     0xfffd,
     0x00af,
     0x02db,
     0xfffd,
     0x00a0,
     0xfffd,
     0x00a2,
     0x00a3,
     0x00a4,
     0xfffd,
     0x00a6,
     0x00a7,
     0x00d8,
     0x00a9,
     0x0156,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x00c6,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x00b4,
     0x00b5,
     0x00b6,
     0x00b7,
     0x00f8,
     0x00b9,
     0x0157,
     0x00bb,
     0x00bc,
     0x00bd,
     0x00be,
     0x00e6,
     0x0104,
     0x012e,
     0x0100,
     0x0106,
     0x00c4,
     0x00c5,
     0x0118,
     0x0112,
     0x010c,
     0x00c9,
     0x0179,
     0x0116,
     0x0122,
     0x0136,
     0x012a,
     0x013b,
     0x0160,
     0x0143,
     0x0145,
     0x00d3,
     0x014c,
     0x00d5,
     0x00d6,
     0x00d7,
     0x0172,
     0x0141,
     0x015a,
     0x016a,
     0x00dc,
     0x017b,
     0x017d,
     0x00df,
     0x0105,
     0x012f,
     0x0101,
     0x0107,
     0x00e4,
     0x00e5,
     0x0119,
     0x0113,
     0x010d,
     0x00e9,
     0x017a,
     0x0117,
     0x0123,
     0x0137,
     0x012b,
     0x013c,
     0x0161,
     0x0144,
     0x0146,
     0x00f3,
     0x014d,
     0x00f5,
     0x00f6,
     0x00f7,
     0x0173,
     0x0142,
     0x015b,
     0x016b,
     0x00fc,
     0x017c,
     0x017e,
     0x02d9,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe2\x82\xac",
     "\xef\xbf\xbd",
     "\xe2\x80\x9a",
     "\xef\xbf\xbd",
     "\xe2\x80\x9e",
     "\xe2\x80\xa6",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xef\xbf\xbd",
     "\xe2\x80\xb0",
     "\xef\xbf\xbd",
     "\xe2\x80\xb9",
     "\xef\xbf\xbd",
     "\xc2\xa8",
     "\xcb\x87",
     "\xc2\xb8",
     "\xef\xbf\xbd",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xef\xbf\xbd",
     "\xe2\x84\xa2",
     "\xef\xbf\xbd",
     "\xe2\x80\xba",
     "\xef\xbf\xbd",
     "\xc2\xaf",
     "\xcb\x9b",
     "\xef\xbf\xbd",
     "\xc2\xa0",
     "\xef\xbf\xbd",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xef\xbf\xbd",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc3\x98",
     "\xc2\xa9",
     "\xc5\x96",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc3\x86",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc3\xb8",
     "\xc2\xb9",
     "\xc5\x97",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc3\xa6",
     "\xc4\x84",
     "\xc4\xae",
     "\xc4\x80",
     "\xc4\x86",
     "\xc3\x84",
     "\xc3\x85",
     "\xc4\x98",
     "\xc4\x92",
     "\xc4\x8c",
     "\xc3\x89",
     "\xc5\xb9",
     "\xc4\x96",
     "\xc4\xa2",
     "\xc4\xb6",
     "\xc4\xaa",
     "\xc4\xbb",
     "\xc5\xa0",
     "\xc5\x83",
     "\xc5\x85",
     "\xc3\x93",
     "\xc5\x8c",
     "\xc3\x95",
     "\xc3\x96",
     "\xc3\x97",
     "\xc5\xb2",
     "\xc5\x81",
     "\xc5\x9a",
     "\xc5\xaa",
     "\xc3\x9c",
     "\xc5\xbb",
     "\xc5\xbd",
     "\xc3\x9f",
     "\xc4\x85",
     "\xc4\xaf",
     "\xc4\x81",
     "\xc4\x87",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc4\x99",
     "\xc4\x93",
     "\xc4\x8d",
     "\xc3\xa9",
     "\xc5\xba",
     "\xc4\x97",
     "\xc4\xa3",
     "\xc4\xb7",
     "\xc4\xab",
     "\xc4\xbc",
     "\xc5\xa1",
     "\xc5\x84",
     "\xc5\x86",
     "\xc3\xb3",
     "\xc5\x8d",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc5\xb3",
     "\xc5\x82",
     "\xc5\x9b",
     "\xc5\xab",
     "\xc3\xbc",
     "\xc5\xbc",
     "\xc5\xbe",
     "\xcb\x99",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\x8d",
     0x000000a9 => "\xa9",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000af => "\x9d",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b8 => "\x8f",
     0x000000b9 => "\xb9",
     0x000000bb => "\xbb",
     0x000000bc => "\xbc",
     0x000000bd => "\xbd",
     0x000000be => "\xbe",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xaf",
     0x000000c9 => "\xc9",
     0x000000d3 => "\xd3",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000d8 => "\xa8",
     0x000000dc => "\xdc",
     0x000000df => "\xdf",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xbf",
     0x000000e9 => "\xe9",
     0x000000f3 => "\xf3",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f8 => "\xb8",
     0x000000fc => "\xfc",
     0x00000100 => "\xc2",
     0x00000101 => "\xe2",
     0x00000104 => "\xc0",
     0x00000105 => "\xe0",
     0x00000106 => "\xc3",
     0x00000107 => "\xe3",
     0x0000010c => "\xc8",
     0x0000010d => "\xe8",
     0x00000112 => "\xc7",
     0x00000113 => "\xe7",
     0x00000116 => "\xcb",
     0x00000117 => "\xeb",
     0x00000118 => "\xc6",
     0x00000119 => "\xe6",
     0x00000122 => "\xcc",
     0x00000123 => "\xec",
     0x0000012a => "\xce",
     0x0000012b => "\xee",
     0x0000012e => "\xc1",
     0x0000012f => "\xe1",
     0x00000136 => "\xcd",
     0x00000137 => "\xed",
     0x0000013b => "\xcf",
     0x0000013c => "\xef",
     0x00000141 => "\xd9",
     0x00000142 => "\xf9",
     0x00000143 => "\xd1",
     0x00000144 => "\xf1",
     0x00000145 => "\xd2",
     0x00000146 => "\xf2",
     0x0000014c => "\xd4",
     0x0000014d => "\xf4",
     0x00000156 => "\xaa",
     0x00000157 => "\xba",
     0x0000015a => "\xda",
     0x0000015b => "\xfa",
     0x00000160 => "\xd0",
     0x00000161 => "\xf0",
     0x0000016a => "\xdb",
     0x0000016b => "\xfb",
     0x00000172 => "\xd8",
     0x00000173 => "\xf8",
     0x00000179 => "\xca",
     0x0000017a => "\xea",
     0x0000017b => "\xdd",
     0x0000017c => "\xfd",
     0x0000017d => "\xde",
     0x0000017e => "\xfe",
     0x000002c7 => "\x8e",
     0x000002d9 => "\xff",
     0x000002db => "\x9e",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201a => "\x82",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x0000201e => "\x84",
     0x00002020 => "\x86",
     0x00002021 => "\x87",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x00002030 => "\x89",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x000020ac => "\x80",
     0x00002122 => "\x99",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/CSN_369103.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::CSN_369103;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x00a4,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x0104,
     0x02d8,
     0x0141,
     0x0024,
     0x013d,
     0x015a,
     0x00a7,
     0x00a8,
     0x0160,
     0x015e,
     0x0164,
     0x0179,
     0x00ad,
     0x017d,
     0x017b,
     0x00b0,
     0x0105,
     0x02db,
     0x0142,
     0x00b4,
     0x013e,
     0x015b,
     0x02c7,
     0x00b8,
     0x0161,
     0x015f,
     0x0165,
     0x017a,
     0x02dd,
     0x017e,
     0x017c,
     0x0154,
     0x00c1,
     0x00c2,
     0x0102,
     0x00c4,
     0x0139,
     0x0106,
     0x00c7,
     0x010c,
     0x00c9,
     0x0118,
     0x00cb,
     0x011a,
     0x00cd,
     0x00ce,
     0x010e,
     0x0110,
     0x0143,
     0x0147,
     0x00d3,
     0x00d4,
     0x0150,
     0x00d6,
     0x00d7,
     0x0158,
     0x016e,
     0x00da,
     0x0170,
     0x00dc,
     0x00dd,
     0x0162,
     0x00df,
     0x0155,
     0x00e1,
     0x00e2,
     0x0103,
     0x00e4,
     0x013a,
     0x0107,
     0x00e7,
     0x010d,
     0x00e9,
     0x0119,
     0x00eb,
     0x011b,
     0x00ed,
     0x00ee,
     0x010f,
     0x0111,
     0x0144,
     0x0148,
     0x00f3,
     0x00f4,
     0x0151,
     0x00f6,
     0x00f7,
     0x0159,
     0x016f,
     0x00fa,
     0x0171,
     0x00fc,
     0x00fd,
     0x0163,
     0x02d9,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\xc2\xa4",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xc4\x84",
     "\xcb\x98",
     "\xc5\x81",
     "\x24",
     "\xc4\xbd",
     "\xc5\x9a",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc5\xa0",
     "\xc5\x9e",
     "\xc5\xa4",
     "\xc5\xb9",
     "\xc2\xad",
     "\xc5\xbd",
     "\xc5\xbb",
     "\xc2\xb0",
     "\xc4\x85",
     "\xcb\x9b",
     "\xc5\x82",
     "\xc2\xb4",
     "\xc4\xbe",
     "\xc5\x9b",
     "\xcb\x87",
     "\xc2\xb8",
     "\xc5\xa1",
     "\xc5\x9f",
     "\xc5\xa5",
     "\xc5\xba",
     "\xcb\x9d",
     "\xc5\xbe",
     "\xc5\xbc",
     "\xc5\x94",
     "\xc3\x81",
     "\xc3\x82",
     "\xc4\x82",
     "\xc3\x84",
     "\xc4\xb9",
     "\xc4\x86",
     "\xc3\x87",
     "\xc4\x8c",
     "\xc3\x89",
     "\xc4\x98",
     "\xc3\x8b",
     "\xc4\x9a",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc4\x8e",
     "\xc4\x90",
     "\xc5\x83",
     "\xc5\x87",
     "\xc3\x93",
     "\xc3\x94",
     "\xc5\x90",
     "\xc3\x96",
     "\xc3\x97",
     "\xc5\x98",
     "\xc5\xae",
     "\xc3\x9a",
     "\xc5\xb0",
     "\xc3\x9c",
     "\xc3\x9d",
     "\xc5\xa2",
     "\xc3\x9f",
     "\xc5\x95",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc4\x83",
     "\xc3\xa4",
     "\xc4\xba",
     "\xc4\x87",
     "\xc3\xa7",
     "\xc4\x8d",
     "\xc3\xa9",
     "\xc4\x99",
     "\xc3\xab",
     "\xc4\x9b",
     "\xc3\xad",
     "\xc3\xae",
     "\xc4\x8f",
     "\xc4\x91",
     "\xc5\x84",
     "\xc5\x88",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc5\x91",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc5\x99",
     "\xc5\xaf",
     "\xc3\xba",
     "\xc5\xb1",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc5\xa3",
     "\xcb\x99",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\xa4",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a4 => "\x24",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000ad => "\xad",
     0x000000b0 => "\xb0",
     0x000000b4 => "\xb4",
     0x000000b8 => "\xb8",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c4 => "\xc4",
     0x000000c7 => "\xc7",
     0x000000c9 => "\xc9",
     0x000000cb => "\xcb",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000da => "\xda",
     0x000000dc => "\xdc",
     0x000000dd => "\xdd",
     0x000000df => "\xdf",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e4 => "\xe4",
     0x000000e7 => "\xe7",
     0x000000e9 => "\xe9",
     0x000000eb => "\xeb",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000fa => "\xfa",
     0x000000fc => "\xfc",
     0x000000fd => "\xfd",
     0x00000102 => "\xc3",
     0x00000103 => "\xe3",
     0x00000104 => "\xa1",
     0x00000105 => "\xb1",
     0x00000106 => "\xc6",
     0x00000107 => "\xe6",
     0x0000010c => "\xc8",
     0x0000010d => "\xe8",
     0x0000010e => "\xcf",
     0x0000010f => "\xef",
     0x00000110 => "\xd0",
     0x00000111 => "\xf0",
     0x00000118 => "\xca",
     0x00000119 => "\xea",
     0x0000011a => "\xcc",
     0x0000011b => "\xec",
     0x00000139 => "\xc5",
     0x0000013a => "\xe5",
     0x0000013d => "\xa5",
     0x0000013e => "\xb5",
     0x00000141 => "\xa3",
     0x00000142 => "\xb3",
     0x00000143 => "\xd1",
     0x00000144 => "\xf1",
     0x00000147 => "\xd2",
     0x00000148 => "\xf2",
     0x00000150 => "\xd5",
     0x00000151 => "\xf5",
     0x00000154 => "\xc0",
     0x00000155 => "\xe0",
     0x00000158 => "\xd8",
     0x00000159 => "\xf8",
     0x0000015a => "\xa6",
     0x0000015b => "\xb6",
     0x0000015e => "\xaa",
     0x0000015f => "\xba",
     0x00000160 => "\xa9",
     0x00000161 => "\xb9",
     0x00000162 => "\xde",
     0x00000163 => "\xfe",
     0x00000164 => "\xab",
     0x00000165 => "\xbb",
     0x0000016e => "\xd9",
     0x0000016f => "\xf9",
     0x00000170 => "\xdb",
     0x00000171 => "\xfb",
     0x00000179 => "\xac",
     0x0000017a => "\xbc",
     0x0000017b => "\xaf",
     0x0000017c => "\xbf",
     0x0000017d => "\xae",
     0x0000017e => "\xbe",
     0x000002c7 => "\xb7",
     0x000002d8 => "\xa2",
     0x000002d9 => "\xff",
     0x000002db => "\xb2",
     0x000002dd => "\xbd",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/CWI.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::CWI;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e5,
     0x00e7,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ef,
     0x00ee,
     0x00cd,
     0x00c4,
     0x00c1,
     0x00c9,
     0x00e6,
     0x00c6,
     0x0151,
     0x00f6,
     0x00d3,
     0x0171,
     0x00da,
     0x0170,
     0x00d6,
     0x00dc,
     0x00a2,
     0x00a3,
     0x00a5,
     0x20a7,
     0xe01f,
     0x00e1,
     0x00ed,
     0x00f3,
     0x00fa,
     0x00f1,
     0x00d1,
     0x00aa,
     0x0150,
     0x00bf,
     0x2310,
     0x00ac,
     0x00bd,
     0x00bc,
     0x00a1,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x2561,
     0x2562,
     0x2556,
     0x2555,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x255c,
     0x255b,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x255e,
     0x255f,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x2567,
     0x2568,
     0x2564,
     0x2565,
     0x2559,
     0x2558,
     0x2552,
     0x2553,
     0x256b,
     0x256a,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x258c,
     0x2590,
     0x2580,
     0x03b1,
     0x03b2,
     0x0393,
     0x03c0,
     0x03a3,
     0x03c3,
     0x03bc,
     0x03c4,
     0x03a6,
     0x0398,
     0x03a9,
     0x03b4,
     0x221e,
     0x2205,
     0x03b5,
     0x2229,
     0x2261,
     0x00b1,
     0x2265,
     0x2264,
     0x2320,
     0x2321,
     0x00f7,
     0x2248,
     0x2218,
     0x00b7,
     0x2022,
     0x221a,
     0x207f,
     0x00b2,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xaf",
     "\xc3\xae",
     "\xc3\x8d",
     "\xc3\x84",
     "\xc3\x81",
     "\xc3\x89",
     "\xc3\xa6",
     "\xc3\x86",
     "\xc5\x91",
     "\xc3\xb6",
     "\xc3\x93",
     "\xc5\xb1",
     "\xc3\x9a",
     "\xc5\xb0",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xe2\x82\xa7",
     "\xee\x80\x9f",
     "\xc3\xa1",
     "\xc3\xad",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc3\xb1",
     "\xc3\x91",
     "\xc2\xaa",
     "\xc5\x90",
     "\xc2\xbf",
     "\xe2\x8c\x90",
     "\xc2\xac",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xc2\xa1",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xe2\x95\xa1",
     "\xe2\x95\xa2",
     "\xe2\x95\x96",
     "\xe2\x95\x95",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xe2\x95\x9c",
     "\xe2\x95\x9b",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xe2\x95\x9e",
     "\xe2\x95\x9f",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xe2\x95\xa7",
     "\xe2\x95\xa8",
     "\xe2\x95\xa4",
     "\xe2\x95\xa5",
     "\xe2\x95\x99",
     "\xe2\x95\x98",
     "\xe2\x95\x92",
     "\xe2\x95\x93",
     "\xe2\x95\xab",
     "\xe2\x95\xaa",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xe2\x96\x8c",
     "\xe2\x96\x90",
     "\xe2\x96\x80",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\x93",
     "\xcf\x80",
     "\xce\xa3",
     "\xcf\x83",
     "\xce\xbc",
     "\xcf\x84",
     "\xce\xa6",
     "\xce\x98",
     "\xce\xa9",
     "\xce\xb4",
     "\xe2\x88\x9e",
     "\xe2\x88\x85",
     "\xce\xb5",
     "\xe2\x88\xa9",
     "\xe2\x89\xa1",
     "\xc2\xb1",
     "\xe2\x89\xa5",
     "\xe2\x89\xa4",
     "\xe2\x8c\xa0",
     "\xe2\x8c\xa1",
     "\xc3\xb7",
     "\xe2\x89\x88",
     "\xe2\x88\x98",
     "\xc2\xb7",
     "\xe2\x80\xa2",
     "\xe2\x88\x9a",
     "\xe2\x81\xbf",
     "\xc2\xb2",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a1 => "\xad",
     0x000000a2 => "\x9b",
     0x000000a3 => "\x9c",
     0x000000a5 => "\x9d",
     0x000000aa => "\xa6",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000b1 => "\xf1",
     0x000000b2 => "\xfd",
     0x000000b7 => "\xf9",
     0x000000bb => "\xaf",
     0x000000bc => "\xac",
     0x000000bd => "\xab",
     0x000000bf => "\xa8",
     0x000000c1 => "\x8f",
     0x000000c4 => "\x8e",
     0x000000c6 => "\x92",
     0x000000c7 => "\x80",
     0x000000c9 => "\x90",
     0x000000cd => "\x8d",
     0x000000d1 => "\xa5",
     0x000000d3 => "\x95",
     0x000000d6 => "\x99",
     0x000000da => "\x97",
     0x000000dc => "\x9a",
     0x000000e0 => "\x85",
     0x000000e1 => "\xa0",
     0x000000e2 => "\x83",
     0x000000e4 => "\x84",
     0x000000e5 => "\x86",
     0x000000e6 => "\x91",
     0x000000e7 => "\x87",
     0x000000e8 => "\x8a",
     0x000000e9 => "\x82",
     0x000000ea => "\x88",
     0x000000eb => "\x89",
     0x000000ed => "\xa1",
     0x000000ee => "\x8c",
     0x000000ef => "\x8b",
     0x000000f1 => "\xa4",
     0x000000f3 => "\xa2",
     0x000000f6 => "\x94",
     0x000000f7 => "\xf6",
     0x000000fa => "\xa3",
     0x000000fc => "\x81",
     0x00000150 => "\xa7",
     0x00000151 => "\x93",
     0x00000170 => "\x98",
     0x00000171 => "\x96",
     0x00000393 => "\xe2",
     0x00000398 => "\xe9",
     0x000003a3 => "\xe4",
     0x000003a6 => "\xe8",
     0x000003a9 => "\xea",
     0x000003b1 => "\xe0",
     0x000003b2 => "\xe1",
     0x000003b4 => "\xeb",
     0x000003b5 => "\xee",
     0x000003bc => "\xe6",
     0x000003c0 => "\xe3",
     0x000003c3 => "\xe5",
     0x000003c4 => "\xe7",
     0x00002022 => "\xfa",
     0x0000207f => "\xfc",
     0x000020a7 => "\x9e",
     0x00002205 => "\xed",
     0x00002218 => "\xf8",
     0x0000221a => "\xfb",
     0x0000221e => "\xec",
     0x00002229 => "\xef",
     0x00002248 => "\xf7",
     0x00002261 => "\xf0",
     0x00002264 => "\xf3",
     0x00002265 => "\xf2",
     0x00002310 => "\xa9",
     0x00002320 => "\xf4",
     0x00002321 => "\xf5",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002552 => "\xd5",
     0x00002553 => "\xd6",
     0x00002554 => "\xc9",
     0x00002555 => "\xb8",
     0x00002556 => "\xb7",
     0x00002557 => "\xbb",
     0x00002558 => "\xd4",
     0x00002559 => "\xd3",
     0x0000255a => "\xc8",
     0x0000255b => "\xbe",
     0x0000255c => "\xbd",
     0x0000255d => "\xbc",
     0x0000255e => "\xc6",
     0x0000255f => "\xc7",
     0x00002560 => "\xcc",
     0x00002561 => "\xb5",
     0x00002562 => "\xb6",
     0x00002563 => "\xb9",
     0x00002564 => "\xd1",
     0x00002565 => "\xd2",
     0x00002566 => "\xcb",
     0x00002567 => "\xcf",
     0x00002568 => "\xd0",
     0x00002569 => "\xca",
     0x0000256a => "\xd8",
     0x0000256b => "\xd7",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x0000258c => "\xdd",
     0x00002590 => "\xde",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
     0x0000e01f => "\x9f",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/DEC_MCS.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::DEC_MCS;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0xfffd,
     0x00a1,
     0x00a2,
     0x00a3,
     0xfffd,
     0x00a5,
     0xfffd,
     0x00a7,
     0x00a4,
     0x00a9,
     0x00aa,
     0x00ab,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0xfffd,
     0x00b5,
     0x00b6,
     0x00b7,
     0xfffd,
     0x00b9,
     0x00ba,
     0x00bb,
     0x00bc,
     0x00bd,
     0xfffd,
     0x00bf,
     0x00c0,
     0x00c1,
     0x00c2,
     0x00c3,
     0x00c4,
     0x00c5,
     0x00c6,
     0x00c7,
     0x00c8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00cc,
     0x00cd,
     0x00ce,
     0x00cf,
     0xfffd,
     0x00d1,
     0x00d2,
     0x00d3,
     0x00d4,
     0x00d5,
     0x00d6,
     0x0152,
     0x00d8,
     0x00d9,
     0x00da,
     0x00db,
     0x00dc,
     0x0178,
     0xfffd,
     0x00df,
     0x00e0,
     0x00e1,
     0x00e2,
     0x00e3,
     0x00e4,
     0x00e5,
     0x00e6,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0xfffd,
     0x00f1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x0153,
     0x00f8,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x00ff,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xef\xbf\xbd",
     "\xc2\xa1",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xef\xbf\xbd",
     "\xc2\xa5",
     "\xef\xbf\xbd",
     "\xc2\xa7",
     "\xc2\xa4",
     "\xc2\xa9",
     "\xc2\xaa",
     "\xc2\xab",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xef\xbf\xbd",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xef\xbf\xbd",
     "\xc2\xb9",
     "\xc2\xba",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xef\xbf\xbd",
     "\xc2\xbf",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x86",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xef\xbf\xbd",
     "\xc3\x91",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xc5\x92",
     "\xc3\x98",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc5\xb8",
     "\xef\xbf\xbd",
     "\xc3\x9f",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xef\xbf\xbd",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc5\x93",
     "\xc3\xb8",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xbf",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a1 => "\xa1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa8",
     0x000000a5 => "\xa5",
     0x000000a7 => "\xa7",
     0x000000a9 => "\xa9",
     0x000000aa => "\xaa",
     0x000000ab => "\xab",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b9 => "\xb9",
     0x000000ba => "\xba",
     0x000000bb => "\xbb",
     0x000000bc => "\xbc",
     0x000000bd => "\xbd",
     0x000000bf => "\xbf",
     0x000000c0 => "\xc0",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c3 => "\xc3",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xc6",
     0x000000c7 => "\xc7",
     0x000000c8 => "\xc8",
     0x000000c9 => "\xc9",
     0x000000ca => "\xca",
     0x000000cb => "\xcb",
     0x000000cc => "\xcc",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000cf => "\xcf",
     0x000000d1 => "\xd1",
     0x000000d2 => "\xd2",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d8 => "\xd8",
     0x000000d9 => "\xd9",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000df => "\xdf",
     0x000000e0 => "\xe0",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e3 => "\xe3",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xe6",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f1 => "\xf1",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f8 => "\xf8",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000ff => "\xfd",
     0x00000152 => "\xd7",
     0x00000153 => "\xf7",
     0x00000178 => "\xdd",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_AT_DE.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_AT_DE;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00c4,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00dc,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x0023,
     0x00a7,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00df,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e4,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00fc,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00d6,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x84",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x9c",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\x23",
     "\xc2\xa7",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x9f",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa4",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xbc",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x96",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a7 => "\x7c",
     0x000000c4 => "\x4a",
     0x000000d6 => "\xe0",
     0x000000dc => "\x5a",
     0x000000df => "\xa1",
     0x000000e4 => "\xc0",
     0x000000f6 => "\x6a",
     0x000000fc => "\xd0",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_AT_DE_A.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_AT_DE_A;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f6,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00fc,
     0x00dc,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00df,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x003a,
     0x00c4,
     0x00d6,
     0x0027,
     0x003d,
     0x00e4,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb6",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xbc",
     "\xc3\x9c",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x9f",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x3a",
     "\xc3\x84",
     "\xc3\x96",
     "\x27",
     "\x3d",
     "\xc3\xa4",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005f => "\x6d",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007c => "\x4f",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000ac => "\x5f",
     0x000000c4 => "\x7b",
     0x000000d6 => "\x7c",
     0x000000dc => "\x5b",
     0x000000df => "\x6a",
     0x000000e4 => "\x7f",
     0x000000f6 => "\x4a",
     0x000000fc => "\x5a",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_CA_FR.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_CA_FR;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0x00e2,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e7,
     0xfffd,
     0x00e0,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0xfffd,
     0x00ea,
     0x00eb,
     0xfffd,
     0xfffd,
     0x00ee,
     0x00ef,
     0xfffd,
     0xfffd,
     0x00b4,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x00c2,
     0xfffd,
     0x00c0,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00c7,
     0xfffd,
     0x00f9,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0x00c9,
     0x00ca,
     0x00cb,
     0xfffd,
     0x00ce,
     0x00cf,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a8,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e9,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0x00f4,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e8,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0x00fb,
     0x00fc,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00b8,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0x00d4,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0x00db,
     0x00dc,
     0x00d9,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xc3\xa2",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa7",
     "\xef\xbf\xbd",
     "\xc3\xa0",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xef\xbf\xbd",
     "\xc3\xaa",
     "\xc3\xab",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xae",
     "\xc3\xaf",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xb4",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xef\xbf\xbd",
     "\xc3\x80",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x87",
     "\xef\xbf\xbd",
     "\xc3\xb9",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xef\xbf\xbd",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa8",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa9",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xc3\xb4",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa8",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xb8",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xc3\x94",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a8 => "\xa1",
     0x000000b4 => "\x5a",
     0x000000b8 => "\xe0",
     0x000000c0 => "\x64",
     0x000000c2 => "\x62",
     0x000000c7 => "\x68",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000ce => "\x75",
     0x000000cf => "\x76",
     0x000000d4 => "\xeb",
     0x000000d9 => "\xfd",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000e0 => "\x4a",
     0x000000e2 => "\x42",
     0x000000e7 => "\x48",
     0x000000e8 => "\xd0",
     0x000000e9 => "\xc0",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f4 => "\xcb",
     0x000000f9 => "\x6a",
     0x000000fb => "\xdb",
     0x000000fc => "\xdc",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_DK_NO.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_DK_NO;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0023,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a4,
     0x00c5,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f8,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x00c6,
     0x00d8,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00fc,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e6,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e5,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005c,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x23",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa4",
     "\xc3\x85",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb8",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\xc3\x86",
     "\xc3\x98",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xbc",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa6",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa5",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5c",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x4a",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005c => "\xe0",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a4 => "\x5a",
     0x000000c5 => "\x5b",
     0x000000c6 => "\x7b",
     0x000000d8 => "\x7c",
     0x000000e5 => "\xd0",
     0x000000e6 => "\xc0",
     0x000000f8 => "\x6a",
     0x000000fc => "\xa1",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_DK_NO_A.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_DK_NO_A;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f8,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e5,
     0x00c5,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x003a,
     0x00c6,
     0x00d8,
     0x0027,
     0x003d,
     0x00e6,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb8",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa5",
     "\xc3\x85",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x3a",
     "\xc3\x86",
     "\xc3\x98",
     "\x27",
     "\x3d",
     "\xc3\xa6",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005f => "\x6d",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007c => "\x4f",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a6 => "\x6a",
     0x000000ac => "\x5f",
     0x000000c5 => "\x5b",
     0x000000c6 => "\x7b",
     0x000000d8 => "\x7c",
     0x000000e5 => "\x5a",
     0x000000e6 => "\x7f",
     0x000000f8 => "\x4a",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_ES.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_ES;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a2,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0021,
     0x20a7,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f1,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x00d1,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a8,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005c,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa2",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x21",
     "\xe2\x82\xa7",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb1",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\xc3\x91",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa8",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5c",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000022 => "\x7f",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005c => "\xe0",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\x4f",
     0x0000007d => "\xd0",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a2 => "\x4a",
     0x000000a8 => "\xa1",
     0x000000ac => "\x5f",
     0x000000d1 => "\x7b",
     0x000000f1 => "\x6a",
     0x000020a7 => "\x5b",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_ES_A.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_ES_A;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a2,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0021,
     0x20a7,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x003a,
     0x00d1,
     0x0040,
     0x0027,
     0x003d,
     0x00f1,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa2",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x21",
     "\xe2\x82\xa7",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x3a",
     "\xc3\x91",
     "\x40",
     "\x27",
     "\x3d",
     "\xc3\xb1",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005f => "\x6d",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007c => "\x4f",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a2 => "\x4a",
     0x000000a6 => "\x6a",
     0x000000ac => "\x5f",
     0x000000d1 => "\x7b",
     0x000000f1 => "\x7f",
     0x000020a7 => "\x5b",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_ES_S.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_ES_S;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a2,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0021,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f1,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x00d1,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a8,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005c,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa2",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x21",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb1",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\xc3\x91",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa8",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5c",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000022 => "\x7f",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005c => "\xe0",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\x4f",
     0x0000007d => "\xd0",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a2 => "\x4a",
     0x000000a8 => "\xa1",
     0x000000ac => "\x5f",
     0x000000d1 => "\x7b",
     0x000000f1 => "\x6a",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_FI_SE.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_FI_SE;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a7,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a4,
     0x00c5,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e9,
     0x003a,
     0x00c4,
     0x00d6,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00fc,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e4,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e5,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00c9,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa7",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa4",
     "\xc3\x85",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa9",
     "\x3a",
     "\xc3\x84",
     "\xc3\x96",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xbc",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa4",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa5",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x89",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a4 => "\x5a",
     0x000000a7 => "\x4a",
     0x000000c4 => "\x7b",
     0x000000c5 => "\x5b",
     0x000000c9 => "\xe0",
     0x000000d6 => "\x7c",
     0x000000e4 => "\xc0",
     0x000000e5 => "\xd0",
     0x000000e9 => "\x79",
     0x000000f6 => "\x6a",
     0x000000fc => "\xa1",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_FI_SE_A.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_FI_SE_A;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f6,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e5,
     0x00c5,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x003a,
     0x00c4,
     0x00d6,
     0x0027,
     0x003d,
     0x00e4,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb6",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa5",
     "\xc3\x85",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x3a",
     "\xc3\x84",
     "\xc3\x96",
     "\x27",
     "\x3d",
     "\xc3\xa4",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005f => "\x6d",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007c => "\x4f",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a6 => "\x6a",
     0x000000ac => "\x5f",
     0x000000c4 => "\x7b",
     0x000000c5 => "\x5b",
     0x000000d6 => "\x7c",
     0x000000e4 => "\x7f",
     0x000000e5 => "\x5a",
     0x000000f6 => "\x4a",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_FR.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_FR;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00b0,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a7,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f9,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x00a3,
     0x00e0,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a8,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e9,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e8,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e7,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xb0",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa7",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb9",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\xc2\xa3",
     "\xc3\xa0",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa8",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa9",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa8",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa7",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a3 => "\x7b",
     0x000000a7 => "\x5a",
     0x000000a8 => "\xa1",
     0x000000b0 => "\x4a",
     0x000000e0 => "\x7c",
     0x000000e7 => "\xe0",
     0x000000e8 => "\xd0",
     0x000000e9 => "\xc0",
     0x000000f9 => "\x6a",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_IS_FRISS.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_IS_FRISS;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e1,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x003c,
     0x002e,
     0x00c1,
     0x0028,
     0x002b,
     0x0021,
     0x00d0,
     0x00e9,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00ed,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0024,
     0x0025,
     0x00c9,
     0x002a,
     0x0029,
     0x003b,
     0x0026,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0023,
     0x2018,
     0x002c,
     0x00de,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00cd,
     0xfffd,
     0xfffd,
     0x007c,
     0x00f0,
     0x003a,
     0x00c6,
     0x00d6,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00dd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00b0,
     0x00f6,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0x005b,
     0x00fd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005d,
     0x00a8,
     0xfffd,
     0xfffd,
     0x00fe,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f3,
     0xfffd,
     0x00e6,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00fa,
     0xfffd,
     0x00b4,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00d3,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00da,
     0x007f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa1",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x3c",
     "\x2e",
     "\xc3\x81",
     "\x28",
     "\x2b",
     "\x21",
     "\xc3\x90",
     "\xc3\xa9",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xad",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x24",
     "\x25",
     "\xc3\x89",
     "\x2a",
     "\x29",
     "\x3b",
     "\x26",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x23",
     "\xe2\x80\x98",
     "\x2c",
     "\xc3\x9e",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x8d",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7c",
     "\xc3\xb0",
     "\x3a",
     "\xc3\x86",
     "\xc3\x96",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x9d",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xb0",
     "\xc3\xb6",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5b",
     "\xc3\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5d",
     "\xc2\xa8",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xbe",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb3",
     "\xef\xbf\xbd",
     "\xc3\xa6",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xba",
     "\xef\xbf\xbd",
     "\xc2\xb4",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x93",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x9a",
     "\x7f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x69",
     0x00000024 => "\x59",
     0x00000025 => "\x5a",
     0x00000026 => "\x5f",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4a",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\xac",
     0x0000005d => "\xbc",
     0x0000005f => "\x6d",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007c => "\x78",
     0x0000007f => "\xff",
     0x000000a8 => "\xbd",
     0x000000b0 => "\xa0",
     0x000000b4 => "\xe0",
     0x000000c1 => "\x4c",
     0x000000c6 => "\x7b",
     0x000000c9 => "\x5b",
     0x000000cd => "\x75",
     0x000000d0 => "\x50",
     0x000000d3 => "\xee",
     0x000000d6 => "\x7c",
     0x000000da => "\xfe",
     0x000000dd => "\x8d",
     0x000000de => "\x6c",
     0x000000e1 => "\x45",
     0x000000e6 => "\xd0",
     0x000000e9 => "\x51",
     0x000000ed => "\x55",
     0x000000f0 => "\x79",
     0x000000f3 => "\xce",
     0x000000f6 => "\xa1",
     0x000000fa => "\xde",
     0x000000fd => "\xad",
     0x000000fe => "\xc0",
     0x00002018 => "\x6a",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_IT.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_IT;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00b0,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e9,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f2,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f9,
     0x003a,
     0x00a3,
     0x00a7,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00ec,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e0,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e8,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e7,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xb0",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa9",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb2",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb9",
     "\x3a",
     "\xc2\xa3",
     "\xc2\xa7",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xac",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa0",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa8",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa7",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a3 => "\x7b",
     0x000000a7 => "\x7c",
     0x000000b0 => "\x4a",
     0x000000e0 => "\xc0",
     0x000000e7 => "\xe0",
     0x000000e8 => "\xd0",
     0x000000e9 => "\x5a",
     0x000000ec => "\xa1",
     0x000000f2 => "\x6a",
     0x000000f9 => "\x79",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_PT.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_PT;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005b,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005d,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f5,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x00c3,
     0x00d5,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e7,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e3,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00b4,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00c7,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5b",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5d",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb5",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\xc3\x83",
     "\xc3\x95",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa7",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa3",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xb4",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x87",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x4a",
     0x0000005d => "\x5a",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000b4 => "\xd0",
     0x000000c3 => "\x7b",
     0x000000c7 => "\xe0",
     0x000000d5 => "\x7c",
     0x000000e3 => "\xc0",
     0x000000e7 => "\xa1",
     0x000000f5 => "\x6a",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_UK.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_UK;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0024,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0021,
     0x00a3,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x203e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005c,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x24",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x21",
     "\xc2\xa3",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\xbe",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5c",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x4a",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005c => "\xe0",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\x4f",
     0x0000007d => "\xd0",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a3 => "\x5b",
     0x000000a6 => "\x6a",
     0x000000ac => "\x5f",
     0x0000203e => "\xa1",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/EBCDIC_US.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::EBCDIC_US;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a2,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0021,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005c,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa2",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x21",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7e",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5c",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005c => "\xe0",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\x4f",
     0x0000007d => "\xd0",
     0x0000007e => "\xa1",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a2 => "\x4a",
     0x000000a6 => "\x6a",
     0x000000ac => "\x5f",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ECMA_CYRILLIC.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ECMA_CYRILLIC;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x0452,
     0x0453,
     0x0451,
     0x0454,
     0x0455,
     0x0456,
     0x0457,
     0x0458,
     0x0459,
     0x045a,
     0x045b,
     0x045c,
     0x00ad,
     0x045e,
     0x045f,
     0x2116,
     0x0402,
     0x0403,
     0x0401,
     0x0404,
     0x0405,
     0x0406,
     0x0407,
     0x0408,
     0x0409,
     0x040a,
     0x040b,
     0x040c,
     0x00a4,
     0x040e,
     0x040f,
     0x044e,
     0x0430,
     0x0431,
     0x0446,
     0x0434,
     0x0435,
     0x0444,
     0x0433,
     0x0445,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x044f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0436,
     0x0432,
     0x044c,
     0x044b,
     0x0437,
     0x0448,
     0x044d,
     0x0449,
     0x0447,
     0x044a,
     0x042e,
     0x0410,
     0x0411,
     0x0426,
     0x0414,
     0x0415,
     0x0424,
     0x0413,
     0x0425,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x042f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0416,
     0x0412,
     0x042c,
     0x042b,
     0x0417,
     0x0428,
     0x042d,
     0x0429,
     0x0427,
     0x042a,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xd1\x92",
     "\xd1\x93",
     "\xd1\x91",
     "\xd1\x94",
     "\xd1\x95",
     "\xd1\x96",
     "\xd1\x97",
     "\xd1\x98",
     "\xd1\x99",
     "\xd1\x9a",
     "\xd1\x9b",
     "\xd1\x9c",
     "\xc2\xad",
     "\xd1\x9e",
     "\xd1\x9f",
     "\xe2\x84\x96",
     "\xd0\x82",
     "\xd0\x83",
     "\xd0\x81",
     "\xd0\x84",
     "\xd0\x85",
     "\xd0\x86",
     "\xd0\x87",
     "\xd0\x88",
     "\xd0\x89",
     "\xd0\x8a",
     "\xd0\x8b",
     "\xd0\x8c",
     "\xc2\xa4",
     "\xd0\x8e",
     "\xd0\x8f",
     "\xd1\x8e",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd1\x86",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd1\x84",
     "\xd0\xb3",
     "\xd1\x85",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x8f",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd0\xb6",
     "\xd0\xb2",
     "\xd1\x8c",
     "\xd1\x8b",
     "\xd0\xb7",
     "\xd1\x88",
     "\xd1\x8d",
     "\xd1\x89",
     "\xd1\x87",
     "\xd1\x8a",
     "\xd0\xae",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\xa6",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\xa4",
     "\xd0\x93",
     "\xd0\xa5",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xaf",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\x96",
     "\xd0\x92",
     "\xd0\xac",
     "\xd0\xab",
     "\xd0\x97",
     "\xd0\xa8",
     "\xd0\xad",
     "\xd0\xa9",
     "\xd0\xa7",
     "\xd0\xaa",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a4 => "\xbd",
     0x000000ad => "\xad",
     0x00000401 => "\xb3",
     0x00000402 => "\xb1",
     0x00000403 => "\xb2",
     0x00000404 => "\xb4",
     0x00000405 => "\xb5",
     0x00000406 => "\xb6",
     0x00000407 => "\xb7",
     0x00000408 => "\xb8",
     0x00000409 => "\xb9",
     0x0000040a => "\xba",
     0x0000040b => "\xbb",
     0x0000040c => "\xbc",
     0x0000040e => "\xbe",
     0x0000040f => "\xbf",
     0x00000410 => "\xe1",
     0x00000411 => "\xe2",
     0x00000412 => "\xf7",
     0x00000413 => "\xe7",
     0x00000414 => "\xe4",
     0x00000415 => "\xe5",
     0x00000416 => "\xf6",
     0x00000417 => "\xfa",
     0x00000418 => "\xe9",
     0x00000419 => "\xea",
     0x0000041a => "\xeb",
     0x0000041b => "\xec",
     0x0000041c => "\xed",
     0x0000041d => "\xee",
     0x0000041e => "\xef",
     0x0000041f => "\xf0",
     0x00000420 => "\xf2",
     0x00000421 => "\xf3",
     0x00000422 => "\xf4",
     0x00000423 => "\xf5",
     0x00000424 => "\xe6",
     0x00000425 => "\xe8",
     0x00000426 => "\xe3",
     0x00000427 => "\xfe",
     0x00000428 => "\xfb",
     0x00000429 => "\xfd",
     0x0000042a => "\xff",
     0x0000042b => "\xf9",
     0x0000042c => "\xf8",
     0x0000042d => "\xfc",
     0x0000042e => "\xe0",
     0x0000042f => "\xf1",
     0x00000430 => "\xc1",
     0x00000431 => "\xc2",
     0x00000432 => "\xd7",
     0x00000433 => "\xc7",
     0x00000434 => "\xc4",
     0x00000435 => "\xc5",
     0x00000436 => "\xd6",
     0x00000437 => "\xda",
     0x00000438 => "\xc9",
     0x00000439 => "\xca",
     0x0000043a => "\xcb",
     0x0000043b => "\xcc",
     0x0000043c => "\xcd",
     0x0000043d => "\xce",
     0x0000043e => "\xcf",
     0x0000043f => "\xd0",
     0x00000440 => "\xd2",
     0x00000441 => "\xd3",
     0x00000442 => "\xd4",
     0x00000443 => "\xd5",
     0x00000444 => "\xc6",
     0x00000445 => "\xc8",
     0x00000446 => "\xc3",
     0x00000447 => "\xde",
     0x00000448 => "\xdb",
     0x00000449 => "\xdd",
     0x0000044a => "\xdf",
     0x0000044b => "\xd9",
     0x0000044c => "\xd8",
     0x0000044d => "\xdc",
     0x0000044e => "\xc0",
     0x0000044f => "\xd1",
     0x00000451 => "\xa3",
     0x00000452 => "\xa1",
     0x00000453 => "\xa2",
     0x00000454 => "\xa4",
     0x00000455 => "\xa5",
     0x00000456 => "\xa6",
     0x00000457 => "\xa7",
     0x00000458 => "\xa8",
     0x00000459 => "\xa9",
     0x0000045a => "\xaa",
     0x0000045b => "\xab",
     0x0000045c => "\xac",
     0x0000045e => "\xae",
     0x0000045f => "\xaf",
     0x00002116 => "\xb0",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/GEORGIAN_ACADEMY.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::GEORGIAN_ACADEMY;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x201a,
     0x0192,
     0x201e,
     0x2026,
     0x2020,
     0x2021,
     0x02c6,
     0x2030,
     0x0160,
     0x2039,
     0x0152,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0x02dc,
     0x2122,
     0x0161,
     0x203a,
     0x0153,
     0x009d,
     0x009e,
     0x0178,
     0x00a0,
     0x00a1,
     0x00a2,
     0x00a3,
     0x00a4,
     0x00a5,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0x00aa,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x00af,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x00b4,
     0x00b5,
     0x00b6,
     0x00b7,
     0x00b8,
     0x00b9,
     0x00ba,
     0x00bb,
     0x00bc,
     0x00bd,
     0x00be,
     0x00bf,
     0x10d0,
     0x10d1,
     0x10d2,
     0x10d3,
     0x10d4,
     0x10d5,
     0x10d6,
     0x10d7,
     0x10d8,
     0x10d9,
     0x10da,
     0x10db,
     0x10dc,
     0x10dd,
     0x10de,
     0x10df,
     0x10e0,
     0x10e1,
     0x10e2,
     0x10e3,
     0x10e4,
     0x10e5,
     0x10e6,
     0x10e7,
     0x10e8,
     0x10e9,
     0x10ea,
     0x10eb,
     0x10ec,
     0x10ed,
     0x10ee,
     0x10ef,
     0x10f0,
     0x10f1,
     0x10f2,
     0x10f3,
     0x10f4,
     0x10f5,
     0x10f6,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00f0,
     0x00f1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x00f7,
     0x00f8,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x00fd,
     0x00fe,
     0x00ff,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xe2\x80\x9a",
     "\xc6\x92",
     "\xe2\x80\x9e",
     "\xe2\x80\xa6",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xcb\x86",
     "\xe2\x80\xb0",
     "\xc5\xa0",
     "\xe2\x80\xb9",
     "\xc5\x92",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xcb\x9c",
     "\xe2\x84\xa2",
     "\xc5\xa1",
     "\xe2\x80\xba",
     "\xc5\x93",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc5\xb8",
     "\xc2\xa0",
     "\xc2\xa1",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xc2\xa5",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xc2\xaa",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc2\xaf",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc2\xb8",
     "\xc2\xb9",
     "\xc2\xba",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xbf",
     "\xe1\x83\x90",
     "\xe1\x83\x91",
     "\xe1\x83\x92",
     "\xe1\x83\x93",
     "\xe1\x83\x94",
     "\xe1\x83\x95",
     "\xe1\x83\x96",
     "\xe1\x83\x97",
     "\xe1\x83\x98",
     "\xe1\x83\x99",
     "\xe1\x83\x9a",
     "\xe1\x83\x9b",
     "\xe1\x83\x9c",
     "\xe1\x83\x9d",
     "\xe1\x83\x9e",
     "\xe1\x83\x9f",
     "\xe1\x83\xa0",
     "\xe1\x83\xa1",
     "\xe1\x83\xa2",
     "\xe1\x83\xa3",
     "\xe1\x83\xa4",
     "\xe1\x83\xa5",
     "\xe1\x83\xa6",
     "\xe1\x83\xa7",
     "\xe1\x83\xa8",
     "\xe1\x83\xa9",
     "\xe1\x83\xaa",
     "\xe1\x83\xab",
     "\xe1\x83\xac",
     "\xe1\x83\xad",
     "\xe1\x83\xae",
     "\xe1\x83\xaf",
     "\xe1\x83\xb0",
     "\xe1\x83\xb1",
     "\xe1\x83\xb2",
     "\xe1\x83\xb3",
     "\xe1\x83\xb4",
     "\xe1\x83\xb5",
     "\xe1\x83\xb6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb0",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc3\xb8",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc3\xbf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x000000a0 => "\xa0",
     0x000000a1 => "\xa1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a5 => "\xa5",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000aa => "\xaa",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000af => "\xaf",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b8 => "\xb8",
     0x000000b9 => "\xb9",
     0x000000ba => "\xba",
     0x000000bb => "\xbb",
     0x000000bc => "\xbc",
     0x000000bd => "\xbd",
     0x000000be => "\xbe",
     0x000000bf => "\xbf",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f0 => "\xf0",
     0x000000f1 => "\xf1",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f8 => "\xf8",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000fd => "\xfd",
     0x000000fe => "\xfe",
     0x000000ff => "\xff",
     0x00000152 => "\x8c",
     0x00000153 => "\x9c",
     0x00000160 => "\x8a",
     0x00000161 => "\x9a",
     0x00000178 => "\x9f",
     0x00000192 => "\x83",
     0x000002c6 => "\x88",
     0x000002dc => "\x98",
     0x000010d0 => "\xc0",
     0x000010d1 => "\xc1",
     0x000010d2 => "\xc2",
     0x000010d3 => "\xc3",
     0x000010d4 => "\xc4",
     0x000010d5 => "\xc5",
     0x000010d6 => "\xc6",
     0x000010d7 => "\xc7",
     0x000010d8 => "\xc8",
     0x000010d9 => "\xc9",
     0x000010da => "\xca",
     0x000010db => "\xcb",
     0x000010dc => "\xcc",
     0x000010dd => "\xcd",
     0x000010de => "\xce",
     0x000010df => "\xcf",
     0x000010e0 => "\xd0",
     0x000010e1 => "\xd1",
     0x000010e2 => "\xd2",
     0x000010e3 => "\xd3",
     0x000010e4 => "\xd4",
     0x000010e5 => "\xd5",
     0x000010e6 => "\xd6",
     0x000010e7 => "\xd7",
     0x000010e8 => "\xd8",
     0x000010e9 => "\xd9",
     0x000010ea => "\xda",
     0x000010eb => "\xdb",
     0x000010ec => "\xdc",
     0x000010ed => "\xdd",
     0x000010ee => "\xde",
     0x000010ef => "\xdf",
     0x000010f0 => "\xe0",
     0x000010f1 => "\xe1",
     0x000010f2 => "\xe2",
     0x000010f3 => "\xe3",
     0x000010f4 => "\xe4",
     0x000010f5 => "\xe5",
     0x000010f6 => "\xe6",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201a => "\x82",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x0000201e => "\x84",
     0x00002020 => "\x86",
     0x00002021 => "\x87",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x00002030 => "\x89",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x00002122 => "\x99",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/GEORGIAN_PS.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::GEORGIAN_PS;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x201a,
     0x0192,
     0x201e,
     0x2026,
     0x2020,
     0x2021,
     0x02c6,
     0x2030,
     0x0160,
     0x2039,
     0x0152,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0x02dc,
     0x2122,
     0x0161,
     0x203a,
     0x0153,
     0x009d,
     0x009e,
     0x0178,
     0x00a0,
     0x00a1,
     0x00a2,
     0x00a3,
     0x00a4,
     0x00a5,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0x00aa,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x00af,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x00b4,
     0x00b5,
     0x00b6,
     0x00b7,
     0x00b8,
     0x00b9,
     0x00ba,
     0x00bb,
     0x00bc,
     0x00bd,
     0x00be,
     0x00bf,
     0x10d0,
     0x10d1,
     0x10d2,
     0x10d3,
     0x10d4,
     0x10d5,
     0x10d6,
     0x10f1,
     0x10d7,
     0x10d8,
     0x10d9,
     0x10da,
     0x10db,
     0x10dc,
     0x10f2,
     0x10dd,
     0x10de,
     0x10df,
     0x10e0,
     0x10e1,
     0x10e2,
     0x10f3,
     0x10e3,
     0x10e4,
     0x10e5,
     0x10e6,
     0x10e7,
     0x10e8,
     0x10e9,
     0x10ea,
     0x10eb,
     0x10ec,
     0x10ed,
     0x10ee,
     0x10f4,
     0x10ef,
     0x10f0,
     0x10f5,
     0x00e6,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00f0,
     0x00f1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x00f7,
     0x00f8,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x00fd,
     0x00fe,
     0x00ff,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xe2\x80\x9a",
     "\xc6\x92",
     "\xe2\x80\x9e",
     "\xe2\x80\xa6",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xcb\x86",
     "\xe2\x80\xb0",
     "\xc5\xa0",
     "\xe2\x80\xb9",
     "\xc5\x92",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xcb\x9c",
     "\xe2\x84\xa2",
     "\xc5\xa1",
     "\xe2\x80\xba",
     "\xc5\x93",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc5\xb8",
     "\xc2\xa0",
     "\xc2\xa1",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xc2\xa5",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xc2\xaa",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc2\xaf",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc2\xb8",
     "\xc2\xb9",
     "\xc2\xba",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xbf",
     "\xe1\x83\x90",
     "\xe1\x83\x91",
     "\xe1\x83\x92",
     "\xe1\x83\x93",
     "\xe1\x83\x94",
     "\xe1\x83\x95",
     "\xe1\x83\x96",
     "\xe1\x83\xb1",
     "\xe1\x83\x97",
     "\xe1\x83\x98",
     "\xe1\x83\x99",
     "\xe1\x83\x9a",
     "\xe1\x83\x9b",
     "\xe1\x83\x9c",
     "\xe1\x83\xb2",
     "\xe1\x83\x9d",
     "\xe1\x83\x9e",
     "\xe1\x83\x9f",
     "\xe1\x83\xa0",
     "\xe1\x83\xa1",
     "\xe1\x83\xa2",
     "\xe1\x83\xb3",
     "\xe1\x83\xa3",
     "\xe1\x83\xa4",
     "\xe1\x83\xa5",
     "\xe1\x83\xa6",
     "\xe1\x83\xa7",
     "\xe1\x83\xa8",
     "\xe1\x83\xa9",
     "\xe1\x83\xaa",
     "\xe1\x83\xab",
     "\xe1\x83\xac",
     "\xe1\x83\xad",
     "\xe1\x83\xae",
     "\xe1\x83\xb4",
     "\xe1\x83\xaf",
     "\xe1\x83\xb0",
     "\xe1\x83\xb5",
     "\xc3\xa6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb0",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc3\xb8",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc3\xbf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x000000a0 => "\xa0",
     0x000000a1 => "\xa1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a5 => "\xa5",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000aa => "\xaa",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000af => "\xaf",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b8 => "\xb8",
     0x000000b9 => "\xb9",
     0x000000ba => "\xba",
     0x000000bb => "\xbb",
     0x000000bc => "\xbc",
     0x000000bd => "\xbd",
     0x000000be => "\xbe",
     0x000000bf => "\xbf",
     0x000000e6 => "\xe6",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f0 => "\xf0",
     0x000000f1 => "\xf1",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f8 => "\xf8",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000fd => "\xfd",
     0x000000fe => "\xfe",
     0x000000ff => "\xff",
     0x00000152 => "\x8c",
     0x00000153 => "\x9c",
     0x00000160 => "\x8a",
     0x00000161 => "\x9a",
     0x00000178 => "\x9f",
     0x00000192 => "\x83",
     0x000002c6 => "\x88",
     0x000002dc => "\x98",
     0x000010d0 => "\xc0",
     0x000010d1 => "\xc1",
     0x000010d2 => "\xc2",
     0x000010d3 => "\xc3",
     0x000010d4 => "\xc4",
     0x000010d5 => "\xc5",
     0x000010d6 => "\xc6",
     0x000010d7 => "\xc8",
     0x000010d8 => "\xc9",
     0x000010d9 => "\xca",
     0x000010da => "\xcb",
     0x000010db => "\xcc",
     0x000010dc => "\xcd",
     0x000010dd => "\xcf",
     0x000010de => "\xd0",
     0x000010df => "\xd1",
     0x000010e0 => "\xd2",
     0x000010e1 => "\xd3",
     0x000010e2 => "\xd4",
     0x000010e3 => "\xd6",
     0x000010e4 => "\xd7",
     0x000010e5 => "\xd8",
     0x000010e6 => "\xd9",
     0x000010e7 => "\xda",
     0x000010e8 => "\xdb",
     0x000010e9 => "\xdc",
     0x000010ea => "\xdd",
     0x000010eb => "\xde",
     0x000010ec => "\xdf",
     0x000010ed => "\xe0",
     0x000010ee => "\xe1",
     0x000010ef => "\xe3",
     0x000010f0 => "\xe4",
     0x000010f1 => "\xc7",
     0x000010f2 => "\xce",
     0x000010f3 => "\xd5",
     0x000010f4 => "\xe2",
     0x000010f5 => "\xe5",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201a => "\x82",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x0000201e => "\x84",
     0x00002020 => "\x86",
     0x00002021 => "\x87",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x00002030 => "\x89",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x00002122 => "\x99",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/GOST_19768_74.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::GOST_19768_74;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x0401,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00ad,
     0xfffd,
     0xfffd,
     0x0410,
     0x0411,
     0x0412,
     0x0413,
     0x0414,
     0x0415,
     0x0416,
     0x0417,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0424,
     0x0425,
     0x0426,
     0x0427,
     0x0428,
     0x0429,
     0x042a,
     0x042b,
     0x042c,
     0x042d,
     0x042e,
     0x042f,
     0x0430,
     0x0431,
     0x0432,
     0x0433,
     0x0434,
     0x0435,
     0x0436,
     0x0437,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0444,
     0x0445,
     0x0446,
     0x0447,
     0x0448,
     0x0449,
     0x044a,
     0x044b,
     0x044c,
     0x044d,
     0x044e,
     0x044f,
     0xfffd,
     0x0451,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xd0\x81",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xad",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\x92",
     "\xd0\x93",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\x96",
     "\xd0\x97",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\xa4",
     "\xd0\xa5",
     "\xd0\xa6",
     "\xd0\xa7",
     "\xd0\xa8",
     "\xd0\xa9",
     "\xd0\xaa",
     "\xd0\xab",
     "\xd0\xac",
     "\xd0\xad",
     "\xd0\xae",
     "\xd0\xaf",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd0\xb2",
     "\xd0\xb3",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd0\xb6",
     "\xd0\xb7",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd1\x84",
     "\xd1\x85",
     "\xd1\x86",
     "\xd1\x87",
     "\xd1\x88",
     "\xd1\x89",
     "\xd1\x8a",
     "\xd1\x8b",
     "\xd1\x8c",
     "\xd1\x8d",
     "\xd1\x8e",
     "\xd1\x8f",
     "\xef\xbf\xbd",
     "\xd1\x91",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000ad => "\xad",
     0x00000401 => "\xa1",
     0x00000410 => "\xb0",
     0x00000411 => "\xb1",
     0x00000412 => "\xb2",
     0x00000413 => "\xb3",
     0x00000414 => "\xb4",
     0x00000415 => "\xb5",
     0x00000416 => "\xb6",
     0x00000417 => "\xb7",
     0x00000418 => "\xb8",
     0x00000419 => "\xb9",
     0x0000041a => "\xba",
     0x0000041b => "\xbb",
     0x0000041c => "\xbc",
     0x0000041d => "\xbd",
     0x0000041e => "\xbe",
     0x0000041f => "\xbf",
     0x00000420 => "\xc0",
     0x00000421 => "\xc1",
     0x00000422 => "\xc2",
     0x00000423 => "\xc3",
     0x00000424 => "\xc4",
     0x00000425 => "\xc5",
     0x00000426 => "\xc6",
     0x00000427 => "\xc7",
     0x00000428 => "\xc8",
     0x00000429 => "\xc9",
     0x0000042a => "\xca",
     0x0000042b => "\xcb",
     0x0000042c => "\xcc",
     0x0000042d => "\xcd",
     0x0000042e => "\xce",
     0x0000042f => "\xcf",
     0x00000430 => "\xd0",
     0x00000431 => "\xd1",
     0x00000432 => "\xd2",
     0x00000433 => "\xd3",
     0x00000434 => "\xd4",
     0x00000435 => "\xd5",
     0x00000436 => "\xd6",
     0x00000437 => "\xd7",
     0x00000438 => "\xd8",
     0x00000439 => "\xd9",
     0x0000043a => "\xda",
     0x0000043b => "\xdb",
     0x0000043c => "\xdc",
     0x0000043d => "\xdd",
     0x0000043e => "\xde",
     0x0000043f => "\xdf",
     0x00000440 => "\xe0",
     0x00000441 => "\xe1",
     0x00000442 => "\xe2",
     0x00000443 => "\xe3",
     0x00000444 => "\xe4",
     0x00000445 => "\xe5",
     0x00000446 => "\xe6",
     0x00000447 => "\xe7",
     0x00000448 => "\xe8",
     0x00000449 => "\xe9",
     0x0000044a => "\xea",
     0x0000044b => "\xeb",
     0x0000044c => "\xec",
     0x0000044d => "\xed",
     0x0000044e => "\xee",
     0x0000044f => "\xef",
     0x00000451 => "\xf1",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/GREEK7.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::GREEK7;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x00a4,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0391,
     0x0392,
     0x0393,
     0x0394,
     0x0395,
     0x0396,
     0x0397,
     0x0398,
     0x0399,
     0xfffd,
     0x039a,
     0x039b,
     0x039c,
     0x039d,
     0x039e,
     0x039f,
     0x03a0,
     0x03a1,
     0x03a3,
     0x03a4,
     0x03a5,
     0x03a6,
     0xfffd,
     0x03a7,
     0x03a8,
     0x03a9,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x03b1,
     0x03b2,
     0x03b3,
     0x03b4,
     0x03b5,
     0x03b6,
     0x03b7,
     0x03b8,
     0x03b9,
     0xfffd,
     0x03ba,
     0x03bb,
     0x03bc,
     0x03bd,
     0x03be,
     0x03bf,
     0x03c0,
     0x03c1,
     0x03c3,
     0x03c4,
     0x03c5,
     0x03c6,
     0x03c2,
     0x03c7,
     0x03c8,
     0x03c9,
     0x007b,
     0x007c,
     0x007d,
     0x203e,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\xc2\xa4",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\xce\x91",
     "\xce\x92",
     "\xce\x93",
     "\xce\x94",
     "\xce\x95",
     "\xce\x96",
     "\xce\x97",
     "\xce\x98",
     "\xce\x99",
     "\xef\xbf\xbd",
     "\xce\x9a",
     "\xce\x9b",
     "\xce\x9c",
     "\xce\x9d",
     "\xce\x9e",
     "\xce\x9f",
     "\xce\xa0",
     "\xce\xa1",
     "\xce\xa3",
     "\xce\xa4",
     "\xce\xa5",
     "\xce\xa6",
     "\xef\xbf\xbd",
     "\xce\xa7",
     "\xce\xa8",
     "\xce\xa9",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\xb3",
     "\xce\xb4",
     "\xce\xb5",
     "\xce\xb6",
     "\xce\xb7",
     "\xce\xb8",
     "\xce\xb9",
     "\xef\xbf\xbd",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xce\xbd",
     "\xce\xbe",
     "\xce\xbf",
     "\xcf\x80",
     "\xcf\x81",
     "\xcf\x83",
     "\xcf\x84",
     "\xcf\x85",
     "\xcf\x86",
     "\xcf\x82",
     "\xcf\x87",
     "\xcf\x88",
     "\xcf\x89",
     "\x7b",
     "\x7c",
     "\x7d",
     "\xe2\x80\xbe",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007f => "\x7f",
     0x000000a4 => "\x24",
     0x00000391 => "\x41",
     0x00000392 => "\x42",
     0x00000393 => "\x43",
     0x00000394 => "\x44",
     0x00000395 => "\x45",
     0x00000396 => "\x46",
     0x00000397 => "\x47",
     0x00000398 => "\x48",
     0x00000399 => "\x49",
     0x0000039a => "\x4b",
     0x0000039b => "\x4c",
     0x0000039c => "\x4d",
     0x0000039d => "\x4e",
     0x0000039e => "\x4f",
     0x0000039f => "\x50",
     0x000003a0 => "\x51",
     0x000003a1 => "\x52",
     0x000003a3 => "\x53",
     0x000003a4 => "\x54",
     0x000003a5 => "\x55",
     0x000003a6 => "\x56",
     0x000003a7 => "\x58",
     0x000003a8 => "\x59",
     0x000003a9 => "\x5a",
     0x000003b1 => "\x61",
     0x000003b2 => "\x62",
     0x000003b3 => "\x63",
     0x000003b4 => "\x64",
     0x000003b5 => "\x65",
     0x000003b6 => "\x66",
     0x000003b7 => "\x67",
     0x000003b8 => "\x68",
     0x000003b9 => "\x69",
     0x000003ba => "\x6b",
     0x000003bb => "\x6c",
     0x000003bc => "\x6d",
     0x000003bd => "\x6e",
     0x000003be => "\x6f",
     0x000003bf => "\x70",
     0x000003c0 => "\x71",
     0x000003c1 => "\x72",
     0x000003c2 => "\x77",
     0x000003c3 => "\x73",
     0x000003c4 => "\x74",
     0x000003c5 => "\x75",
     0x000003c6 => "\x76",
     0x000003c7 => "\x78",
     0x000003c8 => "\x79",
     0x000003c9 => "\x7a",
     0x0000203e => "\x7e",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/GREEK7_OLD.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::GREEK7_OLD;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x00a3,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x00b4,
     0x03b1,
     0x03b2,
     0x03c8,
     0x03b4,
     0x03b5,
     0x03c6,
     0x03b3,
     0x03b7,
     0x03b9,
     0x03be,
     0x03ba,
     0x03bb,
     0x03bc,
     0x03bd,
     0x03bf,
     0x03c0,
     0x037a,
     0x03c1,
     0x03c3,
     0x03c4,
     0x03b8,
     0x03c9,
     0x03c2,
     0x03c7,
     0x03c5,
     0x03b6,
     0x1fcf,
     0x1fbf,
     0x1fce,
     0x007e,
     0x005f,
     0x0060,
     0x0391,
     0x0392,
     0x03a8,
     0x0394,
     0x0395,
     0x03a6,
     0x0393,
     0x0397,
     0x0399,
     0x039e,
     0x039a,
     0x039b,
     0x039c,
     0x039d,
     0x039f,
     0x03a0,
     0xfffd,
     0x03a1,
     0x03a3,
     0x03a4,
     0x0398,
     0x03a9,
     0x00b7,
     0x03a7,
     0x03a5,
     0x0396,
     0x1fdf,
     0x1ffe,
     0x1fde,
     0x00a8,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\xc2\xa3",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\xc2\xb4",
     "\xce\xb1",
     "\xce\xb2",
     "\xcf\x88",
     "\xce\xb4",
     "\xce\xb5",
     "\xcf\x86",
     "\xce\xb3",
     "\xce\xb7",
     "\xce\xb9",
     "\xce\xbe",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xce\xbd",
     "\xce\xbf",
     "\xcf\x80",
     "\xcd\xba",
     "\xcf\x81",
     "\xcf\x83",
     "\xcf\x84",
     "\xce\xb8",
     "\xcf\x89",
     "\xcf\x82",
     "\xcf\x87",
     "\xcf\x85",
     "\xce\xb6",
     "\xe1\xbf\x8f",
     "\xe1\xbe\xbf",
     "\xe1\xbf\x8e",
     "\x7e",
     "\x5f",
     "\x60",
     "\xce\x91",
     "\xce\x92",
     "\xce\xa8",
     "\xce\x94",
     "\xce\x95",
     "\xce\xa6",
     "\xce\x93",
     "\xce\x97",
     "\xce\x99",
     "\xce\x9e",
     "\xce\x9a",
     "\xce\x9b",
     "\xce\x9c",
     "\xce\x9d",
     "\xce\x9f",
     "\xce\xa0",
     "\xef\xbf\xbd",
     "\xce\xa1",
     "\xce\xa3",
     "\xce\xa4",
     "\xce\x98",
     "\xce\xa9",
     "\xc2\xb7",
     "\xce\xa7",
     "\xce\xa5",
     "\xce\x96",
     "\xe1\xbf\x9f",
     "\xe1\xbf\xbe",
     "\xe1\xbf\x9e",
     "\xc2\xa8",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x0000007e => "\x5e",
     0x0000007f => "\x7f",
     0x000000a3 => "\x23",
     0x000000a8 => "\x7e",
     0x000000b4 => "\x40",
     0x000000b7 => "\x77",
     0x0000037a => "\x51",
     0x00000391 => "\x61",
     0x00000392 => "\x62",
     0x00000393 => "\x67",
     0x00000394 => "\x64",
     0x00000395 => "\x65",
     0x00000396 => "\x7a",
     0x00000397 => "\x68",
     0x00000398 => "\x75",
     0x00000399 => "\x69",
     0x0000039a => "\x6b",
     0x0000039b => "\x6c",
     0x0000039c => "\x6d",
     0x0000039d => "\x6e",
     0x0000039e => "\x6a",
     0x0000039f => "\x6f",
     0x000003a0 => "\x70",
     0x000003a1 => "\x72",
     0x000003a3 => "\x73",
     0x000003a4 => "\x74",
     0x000003a5 => "\x79",
     0x000003a6 => "\x66",
     0x000003a7 => "\x78",
     0x000003a8 => "\x63",
     0x000003a9 => "\x76",
     0x000003b1 => "\x41",
     0x000003b2 => "\x42",
     0x000003b3 => "\x47",
     0x000003b4 => "\x44",
     0x000003b5 => "\x45",
     0x000003b6 => "\x5a",
     0x000003b7 => "\x48",
     0x000003b8 => "\x55",
     0x000003b9 => "\x49",
     0x000003ba => "\x4b",
     0x000003bb => "\x4c",
     0x000003bc => "\x4d",
     0x000003bd => "\x4e",
     0x000003be => "\x4a",
     0x000003bf => "\x4f",
     0x000003c0 => "\x50",
     0x000003c1 => "\x52",
     0x000003c2 => "\x57",
     0x000003c3 => "\x53",
     0x000003c4 => "\x54",
     0x000003c5 => "\x59",
     0x000003c6 => "\x46",
     0x000003c7 => "\x58",
     0x000003c8 => "\x43",
     0x000003c9 => "\x56",
     0x00001fbf => "\x5c",
     0x00001fce => "\x5d",
     0x00001fcf => "\x5b",
     0x00001fde => "\x7d",
     0x00001fdf => "\x7b",
     0x00001ffe => "\x7c",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/GREEK_CCITT.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::GREEK_CCITT;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x00a4,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0391,
     0x0392,
     0x0393,
     0x0394,
     0x0395,
     0x0396,
     0x0397,
     0x0398,
     0x0399,
     0x039a,
     0x039b,
     0x039c,
     0x039d,
     0x039e,
     0x039f,
     0x03a0,
     0x03a1,
     0xfffd,
     0x03a3,
     0x03a4,
     0x03a5,
     0x03a6,
     0x03a7,
     0x03a8,
     0x03a9,
     0xfffd,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0xfffd,
     0x03b1,
     0x03b2,
     0x03b3,
     0x03b4,
     0x03b5,
     0x03b6,
     0x03b7,
     0x03b8,
     0x03b9,
     0x03ba,
     0x03bb,
     0x03bc,
     0x03bd,
     0x03be,
     0x03bf,
     0x03c0,
     0x03c1,
     0x03c2,
     0x03c3,
     0x03c4,
     0x03c5,
     0x03c6,
     0x03c7,
     0x03c8,
     0x03c9,
     0xfffd,
     0x007b,
     0x007c,
     0x007d,
     0x00af,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\xc2\xa4",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\xce\x91",
     "\xce\x92",
     "\xce\x93",
     "\xce\x94",
     "\xce\x95",
     "\xce\x96",
     "\xce\x97",
     "\xce\x98",
     "\xce\x99",
     "\xce\x9a",
     "\xce\x9b",
     "\xce\x9c",
     "\xce\x9d",
     "\xce\x9e",
     "\xce\x9f",
     "\xce\xa0",
     "\xce\xa1",
     "\xef\xbf\xbd",
     "\xce\xa3",
     "\xce\xa4",
     "\xce\xa5",
     "\xce\xa6",
     "\xce\xa7",
     "\xce\xa8",
     "\xce\xa9",
     "\xef\xbf\xbd",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\xef\xbf\xbd",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\xb3",
     "\xce\xb4",
     "\xce\xb5",
     "\xce\xb6",
     "\xce\xb7",
     "\xce\xb8",
     "\xce\xb9",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xce\xbd",
     "\xce\xbe",
     "\xce\xbf",
     "\xcf\x80",
     "\xcf\x81",
     "\xcf\x82",
     "\xcf\x83",
     "\xcf\x84",
     "\xcf\x85",
     "\xcf\x86",
     "\xcf\x87",
     "\xcf\x88",
     "\xcf\x89",
     "\xef\xbf\xbd",
     "\x7b",
     "\x7c",
     "\x7d",
     "\xc2\xaf",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007f => "\x7f",
     0x000000a4 => "\x24",
     0x000000af => "\x7e",
     0x00000391 => "\x41",
     0x00000392 => "\x42",
     0x00000393 => "\x43",
     0x00000394 => "\x44",
     0x00000395 => "\x45",
     0x00000396 => "\x46",
     0x00000397 => "\x47",
     0x00000398 => "\x48",
     0x00000399 => "\x49",
     0x0000039a => "\x4a",
     0x0000039b => "\x4b",
     0x0000039c => "\x4c",
     0x0000039d => "\x4d",
     0x0000039e => "\x4e",
     0x0000039f => "\x4f",
     0x000003a0 => "\x50",
     0x000003a1 => "\x51",
     0x000003a3 => "\x53",
     0x000003a4 => "\x54",
     0x000003a5 => "\x55",
     0x000003a6 => "\x56",
     0x000003a7 => "\x57",
     0x000003a8 => "\x58",
     0x000003a9 => "\x59",
     0x000003b1 => "\x61",
     0x000003b2 => "\x62",
     0x000003b3 => "\x63",
     0x000003b4 => "\x64",
     0x000003b5 => "\x65",
     0x000003b6 => "\x66",
     0x000003b7 => "\x67",
     0x000003b8 => "\x68",
     0x000003b9 => "\x69",
     0x000003ba => "\x6a",
     0x000003bb => "\x6b",
     0x000003bc => "\x6c",
     0x000003bd => "\x6d",
     0x000003be => "\x6e",
     0x000003bf => "\x6f",
     0x000003c0 => "\x70",
     0x000003c1 => "\x71",
     0x000003c2 => "\x72",
     0x000003c3 => "\x73",
     0x000003c4 => "\x74",
     0x000003c5 => "\x75",
     0x000003c6 => "\x76",
     0x000003c7 => "\x77",
     0x000003c8 => "\x78",
     0x000003c9 => "\x79",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/HP_ROMAN8.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::HP_ROMAN8;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x00c0,
     0x00c2,
     0x00c8,
     0x00ca,
     0x00cb,
     0x00ce,
     0x00cf,
     0x00b4,
     0x02cb,
     0x02c6,
     0x00a8,
     0x02dc,
     0x00d9,
     0x00db,
     0x20a4,
     0x00af,
     0x00dd,
     0x00fd,
     0x00b0,
     0x00c7,
     0x00e7,
     0x00d1,
     0x00f1,
     0x00a1,
     0x00bf,
     0x00a4,
     0x00a3,
     0x00a5,
     0x00a7,
     0x0192,
     0x00a2,
     0x00e2,
     0x00ea,
     0x00f4,
     0x00fb,
     0x00e1,
     0x00e9,
     0x00f3,
     0x00fa,
     0x00e0,
     0x00e8,
     0x00f2,
     0x00f9,
     0x00e4,
     0x00eb,
     0x00f6,
     0x00fc,
     0x00c5,
     0x00ee,
     0x00d8,
     0x00c6,
     0x00e5,
     0x00ed,
     0x00f8,
     0x00e6,
     0x00c4,
     0x00ec,
     0x00d6,
     0x00dc,
     0x00c9,
     0x00ef,
     0x00df,
     0x00d4,
     0x00c1,
     0x00c3,
     0x00e3,
     0x00d0,
     0x00f0,
     0x00cd,
     0x00cc,
     0x00d3,
     0x00d2,
     0x00d5,
     0x00f5,
     0x0160,
     0x0161,
     0x00da,
     0x0178,
     0x00ff,
     0x00de,
     0x00fe,
     0x00b7,
     0x00b5,
     0x00b6,
     0x00be,
     0x2014,
     0x00bc,
     0x00bd,
     0x00aa,
     0x00ba,
     0x00ab,
     0x25a0,
     0x00bb,
     0x00b1,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xc3\x80",
     "\xc3\x82",
     "\xc3\x88",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc2\xb4",
     "\xcb\x8b",
     "\xcb\x86",
     "\xc2\xa8",
     "\xcb\x9c",
     "\xc3\x99",
     "\xc3\x9b",
     "\xe2\x82\xa4",
     "\xc2\xaf",
     "\xc3\x9d",
     "\xc3\xbd",
     "\xc2\xb0",
     "\xc3\x87",
     "\xc3\xa7",
     "\xc3\x91",
     "\xc3\xb1",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc2\xa4",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc2\xa7",
     "\xc6\x92",
     "\xc2\xa2",
     "\xc3\xa2",
     "\xc3\xaa",
     "\xc3\xb4",
     "\xc3\xbb",
     "\xc3\xa1",
     "\xc3\xa9",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc3\xa0",
     "\xc3\xa8",
     "\xc3\xb2",
     "\xc3\xb9",
     "\xc3\xa4",
     "\xc3\xab",
     "\xc3\xb6",
     "\xc3\xbc",
     "\xc3\x85",
     "\xc3\xae",
     "\xc3\x98",
     "\xc3\x86",
     "\xc3\xa5",
     "\xc3\xad",
     "\xc3\xb8",
     "\xc3\xa6",
     "\xc3\x84",
     "\xc3\xac",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\x89",
     "\xc3\xaf",
     "\xc3\x9f",
     "\xc3\x94",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\xa3",
     "\xc3\x90",
     "\xc3\xb0",
     "\xc3\x8d",
     "\xc3\x8c",
     "\xc3\x93",
     "\xc3\x92",
     "\xc3\x95",
     "\xc3\xb5",
     "\xc5\xa0",
     "\xc5\xa1",
     "\xc3\x9a",
     "\xc5\xb8",
     "\xc3\xbf",
     "\xc3\x9e",
     "\xc3\xbe",
     "\xc2\xb7",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xbe",
     "\xe2\x80\x94",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc2\xab",
     "\xe2\x96\xa0",
     "\xc2\xbb",
     "\xc2\xb1",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a1 => "\xb8",
     0x000000a2 => "\xbf",
     0x000000a3 => "\xbb",
     0x000000a4 => "\xba",
     0x000000a5 => "\xbc",
     0x000000a7 => "\xbd",
     0x000000a8 => "\xab",
     0x000000aa => "\xf9",
     0x000000ab => "\xfb",
     0x000000af => "\xb0",
     0x000000b0 => "\xb3",
     0x000000b1 => "\xfe",
     0x000000b4 => "\xa8",
     0x000000b5 => "\xf3",
     0x000000b6 => "\xf4",
     0x000000b7 => "\xf2",
     0x000000ba => "\xfa",
     0x000000bb => "\xfd",
     0x000000bc => "\xf7",
     0x000000bd => "\xf8",
     0x000000be => "\xf5",
     0x000000bf => "\xb9",
     0x000000c0 => "\xa1",
     0x000000c1 => "\xe0",
     0x000000c2 => "\xa2",
     0x000000c3 => "\xe1",
     0x000000c4 => "\xd8",
     0x000000c5 => "\xd0",
     0x000000c6 => "\xd3",
     0x000000c7 => "\xb4",
     0x000000c8 => "\xa3",
     0x000000c9 => "\xdc",
     0x000000ca => "\xa4",
     0x000000cb => "\xa5",
     0x000000cc => "\xe6",
     0x000000cd => "\xe5",
     0x000000ce => "\xa6",
     0x000000cf => "\xa7",
     0x000000d0 => "\xe3",
     0x000000d1 => "\xb6",
     0x000000d2 => "\xe8",
     0x000000d3 => "\xe7",
     0x000000d4 => "\xdf",
     0x000000d5 => "\xe9",
     0x000000d6 => "\xda",
     0x000000d8 => "\xd2",
     0x000000d9 => "\xad",
     0x000000da => "\xed",
     0x000000db => "\xae",
     0x000000dc => "\xdb",
     0x000000dd => "\xb1",
     0x000000de => "\xf0",
     0x000000df => "\xde",
     0x000000e0 => "\xc8",
     0x000000e1 => "\xc4",
     0x000000e2 => "\xc0",
     0x000000e3 => "\xe2",
     0x000000e4 => "\xcc",
     0x000000e5 => "\xd4",
     0x000000e6 => "\xd7",
     0x000000e7 => "\xb5",
     0x000000e8 => "\xc9",
     0x000000e9 => "\xc5",
     0x000000ea => "\xc1",
     0x000000eb => "\xcd",
     0x000000ec => "\xd9",
     0x000000ed => "\xd5",
     0x000000ee => "\xd1",
     0x000000ef => "\xdd",
     0x000000f0 => "\xe4",
     0x000000f1 => "\xb7",
     0x000000f2 => "\xca",
     0x000000f3 => "\xc6",
     0x000000f4 => "\xc2",
     0x000000f5 => "\xea",
     0x000000f6 => "\xce",
     0x000000f8 => "\xd6",
     0x000000f9 => "\xcb",
     0x000000fa => "\xc7",
     0x000000fb => "\xc3",
     0x000000fc => "\xcf",
     0x000000fd => "\xb2",
     0x000000fe => "\xf1",
     0x000000ff => "\xef",
     0x00000160 => "\xeb",
     0x00000161 => "\xec",
     0x00000178 => "\xee",
     0x00000192 => "\xbe",
     0x000002c6 => "\xaa",
     0x000002cb => "\xa9",
     0x000002dc => "\xac",
     0x00002014 => "\xf6",
     0x000020a4 => "\xaf",
     0x000025a0 => "\xfc",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM037.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM037;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e1,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00f1,
     0x00a2,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x0021,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0x00c3,
     0x00c5,
     0x00c7,
     0x00d1,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x00f0,
     0x00fd,
     0x00fe,
     0x00b1,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x00e6,
     0x00b8,
     0x00c6,
     0x00a4,
     0x00b5,
     0x007e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x00d0,
     0x00dd,
     0x00de,
     0x00ae,
     0x005e,
     0x00a3,
     0x00a5,
     0x00b7,
     0x00a9,
     0x00a7,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x005b,
     0x005d,
     0x00af,
     0x00a8,
     0x00b4,
     0x00d7,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00f3,
     0x00f5,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x00fc,
     0x00f9,
     0x00fa,
     0x00ff,
     0x005c,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x00d6,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x00dc,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xb1",
     "\xc2\xa2",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\x21",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x91",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xb0",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc2\xb1",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc3\xa6",
     "\xc2\xb8",
     "\xc3\x86",
     "\xc2\xa4",
     "\xc2\xb5",
     "\x7e",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc3\x90",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc2\xae",
     "\x5e",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\xc2\xa7",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\x5b",
     "\x5d",
     "\xc2\xaf",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xc3\x97",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbf",
     "\x5c",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\xc3\x96",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\xba",
     0x0000005c => "\xe0",
     0x0000005d => "\xbb",
     0x0000005e => "\xb0",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\x4f",
     0x0000007d => "\xd0",
     0x0000007e => "\xa1",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\x4a",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\x6a",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xbd",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\x5f",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000af => "\xbc",
     0x000000b0 => "\x90",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x63",
     0x000000c5 => "\x67",
     0x000000c6 => "\x9e",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\xac",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\xec",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000dd => "\xad",
     0x000000de => "\xae",
     0x000000df => "\x59",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\x43",
     0x000000e5 => "\x47",
     0x000000e6 => "\x9c",
     0x000000e7 => "\x48",
     0x000000e8 => "\x54",
     0x000000e9 => "\x51",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x8c",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\xcc",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x70",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xdc",
     0x000000fd => "\x8d",
     0x000000fe => "\x8e",
     0x000000ff => "\xdf",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM038.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM038;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005b,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005d,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005c,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5b",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5d",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7e",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5c",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x4a",
     0x0000005c => "\xe0",
     0x0000005d => "\x5a",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007d => "\xd0",
     0x0000007e => "\xa1",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a6 => "\x6a",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM1004.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM1004;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0xfffd,
     0xfffd,
     0x201a,
     0xfffd,
     0x201e,
     0x2026,
     0x2020,
     0x2021,
     0x02c6,
     0x2030,
     0x0160,
     0x2039,
     0x0152,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0x02dc,
     0x2122,
     0x0161,
     0x203a,
     0x0153,
     0xfffd,
     0xfffd,
     0x0178,
     0x00a0,
     0x00a1,
     0x00a2,
     0x00a3,
     0x00a4,
     0x00a5,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0x00aa,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x00af,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x00b4,
     0x00b5,
     0x00b6,
     0x00b7,
     0x00b8,
     0x00b9,
     0x00ba,
     0x00bb,
     0x00bc,
     0x00bd,
     0x00be,
     0x00bf,
     0x00c0,
     0x00c1,
     0x00c2,
     0x00c3,
     0x00c4,
     0x00c5,
     0x00c6,
     0x00c7,
     0x00c8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00cc,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00d0,
     0x00d1,
     0x00d2,
     0x00d3,
     0x00d4,
     0x00d5,
     0x00d6,
     0x00d7,
     0x00d8,
     0x00d9,
     0x00da,
     0x00db,
     0x00dc,
     0x00dd,
     0x00de,
     0x00df,
     0x00e0,
     0x00e1,
     0x00e2,
     0x00e3,
     0x00e4,
     0x00e5,
     0x00e6,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00f0,
     0x00f1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x00f7,
     0x00f8,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x00fd,
     0x00fe,
     0x00ff,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\x9a",
     "\xef\xbf\xbd",
     "\xe2\x80\x9e",
     "\xe2\x80\xa6",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xcb\x86",
     "\xe2\x80\xb0",
     "\xc5\xa0",
     "\xe2\x80\xb9",
     "\xc5\x92",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xcb\x9c",
     "\xe2\x84\xa2",
     "\xc5\xa1",
     "\xe2\x80\xba",
     "\xc5\x93",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc5\xb8",
     "\xc2\xa0",
     "\xc2\xa1",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xc2\xa5",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xc2\xaa",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc2\xaf",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc2\xb8",
     "\xc2\xb9",
     "\xc2\xba",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xbf",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x86",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x90",
     "\xc3\x91",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xc3\x97",
     "\xc3\x98",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc3\x9f",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb0",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc3\xb8",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc3\xbf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x000000a1 => "\xa1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a5 => "\xa5",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000aa => "\xaa",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000af => "\xaf",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b8 => "\xb8",
     0x000000b9 => "\xb9",
     0x000000ba => "\xba",
     0x000000bb => "\xbb",
     0x000000bc => "\xbc",
     0x000000bd => "\xbd",
     0x000000be => "\xbe",
     0x000000bf => "\xbf",
     0x000000c0 => "\xc0",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c3 => "\xc3",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xc6",
     0x000000c7 => "\xc7",
     0x000000c8 => "\xc8",
     0x000000c9 => "\xc9",
     0x000000ca => "\xca",
     0x000000cb => "\xcb",
     0x000000cc => "\xcc",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000cf => "\xcf",
     0x000000d0 => "\xd0",
     0x000000d1 => "\xd1",
     0x000000d2 => "\xd2",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000d8 => "\xd8",
     0x000000d9 => "\xd9",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000dd => "\xdd",
     0x000000de => "\xde",
     0x000000df => "\xdf",
     0x000000e0 => "\xe0",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e3 => "\xe3",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xe6",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f0 => "\xf0",
     0x000000f1 => "\xf1",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f8 => "\xf8",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000fd => "\xfd",
     0x000000fe => "\xfe",
     0x000000ff => "\xff",
     0x00000152 => "\x8c",
     0x00000153 => "\x9c",
     0x00000160 => "\x8a",
     0x00000161 => "\x9a",
     0x00000178 => "\x9f",
     0x000002c6 => "\x88",
     0x000002dc => "\x98",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201a => "\x82",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x0000201e => "\x84",
     0x00002020 => "\x86",
     0x00002021 => "\x87",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x00002030 => "\x89",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x00002122 => "\x99",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM1026.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM1026;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e1,
     0x00e3,
     0x00e5,
     0x007b,
     0x00f1,
     0x00c7,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x011e,
     0x0130,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0x00c3,
     0x00c5,
     0x005b,
     0x00d1,
     0x015f,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x0131,
     0x003a,
     0x00d6,
     0x015e,
     0x0027,
     0x003d,
     0x00dc,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x007d,
     0x0060,
     0x00a6,
     0x00b1,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x00e6,
     0x02db,
     0x00c6,
     0x00a4,
     0x00b5,
     0x00f6,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x005d,
     0x0024,
     0x0040,
     0x00ae,
     0x00a2,
     0x00a3,
     0x00a5,
     0x00b7,
     0x00a9,
     0x00a7,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x00ac,
     0x007c,
     0x2014,
     0x00a8,
     0x00b4,
     0x00d7,
     0x00e7,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x007e,
     0x00f2,
     0x00f3,
     0x00f5,
     0x011f,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x005c,
     0x00f9,
     0x00fa,
     0x00ff,
     0x00fc,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x0023,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x0022,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa3",
     "\xc3\xa5",
     "\x7b",
     "\xc3\xb1",
     "\xc3\x87",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\xc4\x9e",
     "\xc4\xb0",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\x85",
     "\x5b",
     "\xc3\x91",
     "\xc5\x9f",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc4\xb1",
     "\x3a",
     "\xc3\x96",
     "\xc5\x9e",
     "\x27",
     "\x3d",
     "\xc3\x9c",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\x7d",
     "\x60",
     "\xc2\xa6",
     "\xc2\xb1",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc3\xa6",
     "\xcb\x9b",
     "\xc3\x86",
     "\xc2\xa4",
     "\xc2\xb5",
     "\xc3\xb6",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\x5d",
     "\x24",
     "\x40",
     "\xc2\xae",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\xc2\xa7",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xac",
     "\x7c",
     "\xe2\x80\x94",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xc3\x97",
     "\xc3\xa7",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\x7e",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\xc4\x9f",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\x5c",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbf",
     "\xc3\xbc",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\x23",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\x22",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\xfc",
     0x00000023 => "\xec",
     0x00000024 => "\xad",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\xae",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x68",
     0x0000005c => "\xdc",
     0x0000005d => "\xac",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x8d",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\x48",
     0x0000007c => "\xbb",
     0x0000007d => "\x8c",
     0x0000007e => "\xcc",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\xb0",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\x8e",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xbd",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\xba",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000b0 => "\x90",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x63",
     0x000000c5 => "\x67",
     0x000000c6 => "\x9e",
     0x000000c7 => "\x4a",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\x7b",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\x7f",
     0x000000df => "\x59",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\x43",
     0x000000e5 => "\x47",
     0x000000e6 => "\x9c",
     0x000000e7 => "\xc0",
     0x000000e8 => "\x54",
     0x000000e9 => "\x51",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\xa1",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x70",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xe0",
     0x000000ff => "\xdf",
     0x0000011e => "\x5a",
     0x0000011f => "\xd0",
     0x00000130 => "\x5b",
     0x00000131 => "\x79",
     0x0000015e => "\x7c",
     0x0000015f => "\x6a",
     0x000002db => "\x9d",
     0x00002014 => "\xbc",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM1047.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM1047;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e1,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00f1,
     0x00a2,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x0021,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0x00c3,
     0x00c5,
     0x00c7,
     0x00d1,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x00f0,
     0x00fd,
     0x00fe,
     0x00b1,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x00e6,
     0x00b8,
     0x00c6,
     0x00a4,
     0x00b5,
     0x007e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x00d0,
     0x005b,
     0x00de,
     0x00ae,
     0x00ac,
     0x00a3,
     0x00a5,
     0x00b7,
     0x00a9,
     0x00a7,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x00dd,
     0x00a8,
     0x00af,
     0x005d,
     0x00b4,
     0x00d7,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00f3,
     0x00f5,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x00fc,
     0x00f9,
     0x00fa,
     0x00ff,
     0x005c,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x00d6,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x00dc,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xb1",
     "\xc2\xa2",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\x21",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x91",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xb0",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc2\xb1",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc3\xa6",
     "\xc2\xb8",
     "\xc3\x86",
     "\xc2\xa4",
     "\xc2\xb5",
     "\x7e",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc3\x90",
     "\x5b",
     "\xc3\x9e",
     "\xc2\xae",
     "\xc2\xac",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\xc2\xa7",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc3\x9d",
     "\xc2\xa8",
     "\xc2\xaf",
     "\x5d",
     "\xc2\xb4",
     "\xc3\x97",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbf",
     "\x5c",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\xc3\x96",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\xad",
     0x0000005c => "\xe0",
     0x0000005d => "\xbd",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\x4f",
     0x0000007d => "\xd0",
     0x0000007e => "\xa1",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\x4a",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\x6a",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xbb",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\xb0",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000af => "\xbc",
     0x000000b0 => "\x90",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x63",
     0x000000c5 => "\x67",
     0x000000c6 => "\x9e",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\xac",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\xec",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000dd => "\xba",
     0x000000de => "\xae",
     0x000000df => "\x59",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\x43",
     0x000000e5 => "\x47",
     0x000000e6 => "\x9c",
     0x000000e7 => "\x48",
     0x000000e8 => "\x54",
     0x000000e9 => "\x51",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x8c",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\xcc",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x70",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xdc",
     0x000000fd => "\x8d",
     0x000000fe => "\x8e",
     0x000000ff => "\xdf",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM256.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM256;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e1,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00f1,
     0x005b,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x005d,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0x00c3,
     0x00c5,
     0x00c7,
     0x00d1,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x00f0,
     0x00fd,
     0x00fe,
     0x00b1,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x00e6,
     0x00b8,
     0x00c6,
     0x00a4,
     0x00b5,
     0x007e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x00d0,
     0x00dd,
     0x00de,
     0x00ae,
     0x00a2,
     0x00a3,
     0x00a5,
     0x20a7,
     0x0192,
     0x00a7,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x00ac,
     0x007c,
     0x203e,
     0x00a8,
     0x00b4,
     0x2017,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00f3,
     0x00f5,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x00fc,
     0x00f9,
     0x00fa,
     0x00ff,
     0x005c,
     0x2003,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x00d6,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x00dc,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xb1",
     "\x5b",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\x5d",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x91",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xb0",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc2\xb1",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc3\xa6",
     "\xc2\xb8",
     "\xc3\x86",
     "\xc2\xa4",
     "\xc2\xb5",
     "\x7e",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc3\x90",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc2\xae",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xe2\x82\xa7",
     "\xc6\x92",
     "\xc2\xa7",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xac",
     "\x7c",
     "\xe2\x80\xbe",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xe2\x80\x97",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbf",
     "\x5c",
     "\xe2\x80\x83",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\xc3\x96",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x4a",
     0x0000005c => "\xe0",
     0x0000005d => "\x5a",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\xbb",
     0x0000007d => "\xd0",
     0x0000007e => "\xa1",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\xb0",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\x6a",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xbd",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\xba",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000b0 => "\x90",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x63",
     0x000000c5 => "\x67",
     0x000000c6 => "\x9e",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\xac",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\xec",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000dd => "\xad",
     0x000000de => "\xae",
     0x000000df => "\x59",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\x43",
     0x000000e5 => "\x47",
     0x000000e6 => "\x9c",
     0x000000e7 => "\x48",
     0x000000e8 => "\x54",
     0x000000e9 => "\x51",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x8c",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\xcc",
     0x000000f8 => "\x70",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xdc",
     0x000000fd => "\x8d",
     0x000000fe => "\x8e",
     0x000000ff => "\xdf",
     0x00000192 => "\xb4",
     0x00002003 => "\xe1",
     0x00002017 => "\xbf",
     0x0000203e => "\xbc",
     0x000020a7 => "\xb3",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM273.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM273;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x007b,
     0x00e0,
     0x00e1,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00f1,
     0x00c4,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x007e,
     0x00dc,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x00c2,
     0x005b,
     0x00c0,
     0x00c1,
     0x00c3,
     0x00c5,
     0x00c7,
     0x00d1,
     0x00f6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x0060,
     0x003a,
     0x0023,
     0x00a7,
     0x0027,
     0x003d,
     0x0022,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x00f0,
     0x00fd,
     0x00fe,
     0x00b1,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x00e6,
     0x00b8,
     0x00c6,
     0x00a4,
     0x00b5,
     0x00df,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x00d0,
     0x00dd,
     0x00de,
     0x00ae,
     0x00a2,
     0x00a3,
     0x00a5,
     0x00b7,
     0x00a9,
     0x0040,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x00ac,
     0x007c,
     0x203e,
     0x00a8,
     0x00b4,
     0x00d7,
     0x00e4,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00a6,
     0x00f2,
     0x00f3,
     0x00f5,
     0x00fc,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x007d,
     0x00f9,
     0x00fa,
     0x00ff,
     0x00d6,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x005c,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x005d,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\x7b",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xb1",
     "\xc3\x84",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\x7e",
     "\xc3\x9c",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\x5b",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x91",
     "\xc3\xb6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\x60",
     "\x3a",
     "\x23",
     "\xc2\xa7",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xb0",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc2\xb1",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc3\xa6",
     "\xc2\xb8",
     "\xc3\x86",
     "\xc2\xa4",
     "\xc2\xb5",
     "\xc3\x9f",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc3\x90",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc2\xae",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\x40",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xac",
     "\x7c",
     "\xe2\x80\xbe",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xc3\x97",
     "\xc3\xa4",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc2\xa6",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\xc3\xbc",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\x7d",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbf",
     "\xc3\x96",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\x5c",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\x5d",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\xb5",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x63",
     0x0000005c => "\xec",
     0x0000005d => "\xfc",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\x43",
     0x0000007c => "\xbb",
     0x0000007d => "\xdc",
     0x0000007e => "\x59",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\xb0",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\xcc",
     0x000000a7 => "\x7c",
     0x000000a8 => "\xbd",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\xba",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000b0 => "\x90",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x4a",
     0x000000c5 => "\x67",
     0x000000c6 => "\x9e",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\xac",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\xe0",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\x5a",
     0x000000dd => "\xad",
     0x000000de => "\xae",
     0x000000df => "\xa1",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\xc0",
     0x000000e5 => "\x47",
     0x000000e6 => "\x9c",
     0x000000e7 => "\x48",
     0x000000e8 => "\x54",
     0x000000e9 => "\x51",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x8c",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\x6a",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x70",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xd0",
     0x000000fd => "\x8d",
     0x000000fe => "\x8e",
     0x000000ff => "\xdf",
     0x0000203e => "\xbc",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM274.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM274;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005b,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005d,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f9,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x0023,
     0x00e0,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a8,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e9,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e8,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e7,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5b",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5d",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb9",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\x23",
     "\xc3\xa0",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa8",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa9",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa8",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa7",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x4a",
     0x0000005d => "\x5a",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a8 => "\xa1",
     0x000000e0 => "\x7c",
     0x000000e7 => "\xe0",
     0x000000e8 => "\xd0",
     0x000000e9 => "\xc0",
     0x000000f9 => "\x6a",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM275.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM275;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00c9,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0024,
     0x00c7,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e7,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e3,
     0x003a,
     0x00d5,
     0x00c3,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00f5,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00e9,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005c,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\x89",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x24",
     "\xc3\x87",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa7",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa3",
     "\x3a",
     "\xc3\x95",
     "\xc3\x83",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7e",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xb5",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc3\xa9",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5c",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000024 => "\x5a",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005c => "\xe0",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007e => "\xa1",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000c3 => "\x7c",
     0x000000c7 => "\x5b",
     0x000000c9 => "\x4a",
     0x000000d5 => "\x7b",
     0x000000e3 => "\x79",
     0x000000e7 => "\x6a",
     0x000000e9 => "\xd0",
     0x000000f5 => "\xc0",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM277.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM277;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e1,
     0x00e3,
     0x007d,
     0x00e7,
     0x00f1,
     0x0023,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x00a4,
     0x00c5,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0x00c3,
     0x0024,
     0x00c7,
     0x00d1,
     0x00f8,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00a6,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x0060,
     0x003a,
     0x00c6,
     0x00d8,
     0x0027,
     0x003d,
     0x0022,
     0x0040,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x00f0,
     0x00fd,
     0x00fe,
     0x00b1,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x007b,
     0x00b8,
     0x005b,
     0x005d,
     0x00b5,
     0x00fc,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x00d0,
     0x00dd,
     0x00de,
     0x00ae,
     0x00a2,
     0x00a3,
     0x00a5,
     0x00b7,
     0x00a9,
     0x00a7,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x00ac,
     0x007c,
     0x203e,
     0x00a8,
     0x00b4,
     0x00d7,
     0x00e6,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00f3,
     0x00f5,
     0x00e5,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x007e,
     0x00f9,
     0x00fa,
     0x00ff,
     0x005c,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x00d6,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x00dc,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa3",
     "\x7d",
     "\xc3\xa7",
     "\xc3\xb1",
     "\x23",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\xc2\xa4",
     "\xc3\x85",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\x24",
     "\xc3\x87",
     "\xc3\x91",
     "\xc3\xb8",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc2\xa6",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\x60",
     "\x3a",
     "\xc3\x86",
     "\xc3\x98",
     "\x27",
     "\x3d",
     "\x22",
     "\x40",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xb0",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc2\xb1",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\x7b",
     "\xc2\xb8",
     "\x5b",
     "\x5d",
     "\xc2\xb5",
     "\xc3\xbc",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc3\x90",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc2\xae",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\xc2\xa7",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xac",
     "\x7c",
     "\xe2\x80\xbe",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xc3\x97",
     "\xc3\xa6",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\xc3\xa5",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\x7e",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbf",
     "\x5c",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\xc3\x96",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x4a",
     0x00000024 => "\x67",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x80",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x9e",
     0x0000005c => "\xe0",
     0x0000005d => "\x9f",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\x9c",
     0x0000007c => "\xbb",
     0x0000007d => "\x47",
     0x0000007e => "\xdc",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\xb0",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x5a",
     0x000000a5 => "\xb2",
     0x000000a6 => "\x70",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xbd",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\xba",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000b0 => "\x90",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x63",
     0x000000c5 => "\x5b",
     0x000000c6 => "\x7b",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\xac",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\xec",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x7c",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000dd => "\xad",
     0x000000de => "\xae",
     0x000000df => "\x59",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\x43",
     0x000000e5 => "\xd0",
     0x000000e6 => "\xc0",
     0x000000e7 => "\x48",
     0x000000e8 => "\x54",
     0x000000e9 => "\x51",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x8c",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\xcc",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x6a",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xa1",
     0x000000fd => "\x8d",
     0x000000fe => "\x8e",
     0x000000ff => "\xdf",
     0x0000203e => "\xbc",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM278.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM278;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x007b,
     0x00e0,
     0x00e1,
     0x00e3,
     0x007d,
     0x00e7,
     0x00f1,
     0x00a7,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x0060,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x00a4,
     0x00c5,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x00c2,
     0x0023,
     0x00c0,
     0x00c1,
     0x00c3,
     0x0024,
     0x00c7,
     0x00d1,
     0x00f6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x00e9,
     0x003a,
     0x00c4,
     0x00d6,
     0x0027,
     0x003d,
     0x0022,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x00f0,
     0x00fd,
     0x00fe,
     0x00b1,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x00e6,
     0x00b8,
     0x00c6,
     0x005d,
     0x00b5,
     0x00fc,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x00d0,
     0x00dd,
     0x00de,
     0x00ae,
     0x00a2,
     0x00a3,
     0x00a5,
     0x00b7,
     0x00a9,
     0x005b,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x00ac,
     0x007c,
     0x203e,
     0x00a8,
     0x00b4,
     0x00d7,
     0x00e4,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00a6,
     0x00f2,
     0x00f3,
     0x00f5,
     0x00e5,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x007e,
     0x00f9,
     0x00fa,
     0x00ff,
     0x005c,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x0040,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x00dc,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\x7b",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa3",
     "\x7d",
     "\xc3\xa7",
     "\xc3\xb1",
     "\xc2\xa7",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\x60",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\xc2\xa4",
     "\xc3\x85",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\x23",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\x24",
     "\xc3\x87",
     "\xc3\x91",
     "\xc3\xb6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc3\xa9",
     "\x3a",
     "\xc3\x84",
     "\xc3\x96",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xb0",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc2\xb1",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc3\xa6",
     "\xc2\xb8",
     "\xc3\x86",
     "\x5d",
     "\xc2\xb5",
     "\xc3\xbc",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc3\x90",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc2\xae",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\x5b",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xac",
     "\x7c",
     "\xe2\x80\xbe",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xc3\x97",
     "\xc3\xa4",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc2\xa6",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\xc3\xa5",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\x7e",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbf",
     "\x5c",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\x40",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x63",
     0x00000024 => "\x67",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\xec",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\xb5",
     0x0000005c => "\xe0",
     0x0000005d => "\x9f",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x51",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\x43",
     0x0000007c => "\xbb",
     0x0000007d => "\x47",
     0x0000007e => "\xdc",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\xb0",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x5a",
     0x000000a5 => "\xb2",
     0x000000a6 => "\xcc",
     0x000000a7 => "\x4a",
     0x000000a8 => "\xbd",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\xba",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000b0 => "\x90",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x7b",
     0x000000c5 => "\x5b",
     0x000000c6 => "\x9e",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\xac",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\x7c",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000dd => "\xad",
     0x000000de => "\xae",
     0x000000df => "\x59",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\xc0",
     0x000000e5 => "\xd0",
     0x000000e6 => "\x9c",
     0x000000e7 => "\x48",
     0x000000e8 => "\x54",
     0x000000e9 => "\x79",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x8c",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\x6a",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x70",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xa1",
     0x000000fd => "\x8d",
     0x000000fe => "\x8e",
     0x000000ff => "\xdf",
     0x0000203e => "\xbc",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM280.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM280;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x00e4,
     0x007b,
     0x00e1,
     0x00e3,
     0x00e5,
     0x005c,
     0x00f1,
     0x00b0,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x005d,
     0x00ea,
     0x00eb,
     0x007d,
     0x00ed,
     0x00ee,
     0x00ef,
     0x007e,
     0x00df,
     0x00e9,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0x00c3,
     0x00c5,
     0x00c7,
     0x00d1,
     0x00f2,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x00f9,
     0x003a,
     0x00a3,
     0x00a7,
     0x0027,
     0x003d,
     0x0022,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x00f0,
     0x00fd,
     0x00fe,
     0x00b1,
     0x005b,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x00e6,
     0x00b8,
     0x00c6,
     0x00a4,
     0x00b5,
     0x00ec,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x00d0,
     0x00dd,
     0x00de,
     0x00ae,
     0x00a2,
     0x0023,
     0x00a5,
     0x00b7,
     0x00a9,
     0x0040,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x00ac,
     0x007c,
     0x203e,
     0x00a8,
     0x00b4,
     0x00d7,
     0x00e0,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00f6,
     0x00a6,
     0x00f3,
     0x00f5,
     0x00e8,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x00fc,
     0x0060,
     0x00fa,
     0x00ff,
     0x00e7,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x00d6,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x00dc,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\x7b",
     "\xc3\xa1",
     "\xc3\xa3",
     "\xc3\xa5",
     "\x5c",
     "\xc3\xb1",
     "\xc2\xb0",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\x5d",
     "\xc3\xaa",
     "\xc3\xab",
     "\x7d",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\x7e",
     "\xc3\x9f",
     "\xc3\xa9",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x91",
     "\xc3\xb2",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc3\xb9",
     "\x3a",
     "\xc2\xa3",
     "\xc2\xa7",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xb0",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc2\xb1",
     "\x5b",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc3\xa6",
     "\xc2\xb8",
     "\xc3\x86",
     "\xc2\xa4",
     "\xc2\xb5",
     "\xc3\xac",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc3\x90",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc2\xae",
     "\xc2\xa2",
     "\x23",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\x40",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xac",
     "\x7c",
     "\xe2\x80\xbe",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xc3\x97",
     "\xc3\xa0",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc2\xa6",
     "\xc3\xb3",
     "\xc3\xb5",
     "\xc3\xa8",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\x60",
     "\xc3\xba",
     "\xc3\xbf",
     "\xc3\xa7",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\xc3\x96",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\xb1",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\xb5",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x90",
     0x0000005c => "\x48",
     0x0000005d => "\x51",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\xdd",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\x44",
     0x0000007c => "\xbb",
     0x0000007d => "\x54",
     0x0000007e => "\x58",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\xb0",
     0x000000a3 => "\x7b",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\xcd",
     0x000000a7 => "\x7c",
     0x000000a8 => "\xbd",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\xba",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000b0 => "\x4a",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x63",
     0x000000c5 => "\x67",
     0x000000c6 => "\x9e",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\xac",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\xec",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000dd => "\xad",
     0x000000de => "\xae",
     0x000000df => "\x59",
     0x000000e0 => "\xc0",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\x43",
     0x000000e5 => "\x47",
     0x000000e6 => "\x9c",
     0x000000e7 => "\xe0",
     0x000000e8 => "\xd0",
     0x000000e9 => "\x5a",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\xa1",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x8c",
     0x000000f1 => "\x49",
     0x000000f2 => "\x6a",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\xcc",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x70",
     0x000000f9 => "\x79",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xdc",
     0x000000fd => "\x8d",
     0x000000fe => "\x8e",
     0x000000ff => "\xdf",
     0x0000203e => "\xbc",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM281.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM281;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a3,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0021,
     0x00a5,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x203e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0024,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa3",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x21",
     "\xc2\xa5",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\xbe",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x24",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\xe0",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\x4f",
     0x0000007d => "\xd0",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a3 => "\x4a",
     0x000000a5 => "\x5b",
     0x000000a6 => "\x6a",
     0x000000ac => "\x5f",
     0x0000203e => "\xa1",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM284.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM284;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e1,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00a6,
     0x005b,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x005d,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0x00c3,
     0x00c5,
     0x00c7,
     0x0023,
     0x00f1,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x0060,
     0x003a,
     0x00d1,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x00f0,
     0x00fd,
     0x00fe,
     0x00b1,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x00e6,
     0x00b8,
     0x00c6,
     0x00a4,
     0x00b5,
     0x00a8,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x00d0,
     0x00dd,
     0x00de,
     0x00ae,
     0x00a2,
     0x00a3,
     0x00a5,
     0x00b7,
     0x00a9,
     0x00a7,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x005e,
     0x0021,
     0x203e,
     0x007e,
     0x00b4,
     0x00d7,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00f3,
     0x00f5,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x00fc,
     0x00f9,
     0x00fa,
     0x00ff,
     0x005c,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x00d6,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x00dc,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc2\xa6",
     "\x5b",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\x5d",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\x85",
     "\xc3\x87",
     "\x23",
     "\xc3\xb1",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\x60",
     "\x3a",
     "\xc3\x91",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xb0",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc2\xb1",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc3\xa6",
     "\xc2\xb8",
     "\xc3\x86",
     "\xc2\xa4",
     "\xc2\xb5",
     "\xc2\xa8",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc3\x90",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc2\xae",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\xc2\xa7",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\x5e",
     "\x21",
     "\xe2\x80\xbe",
     "\x7e",
     "\xc2\xb4",
     "\xc3\x97",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbf",
     "\x5c",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\xc3\x96",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\xbb",
     0x00000022 => "\x7f",
     0x00000023 => "\x69",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x4a",
     0x0000005c => "\xe0",
     0x0000005d => "\x5a",
     0x0000005e => "\xba",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\x4f",
     0x0000007d => "\xd0",
     0x0000007e => "\xbd",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\xb0",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\x49",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xa1",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\x5f",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000b0 => "\x90",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x63",
     0x000000c5 => "\x67",
     0x000000c6 => "\x9e",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\xac",
     0x000000d1 => "\x7b",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\xec",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000dd => "\xad",
     0x000000de => "\xae",
     0x000000df => "\x59",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\x43",
     0x000000e5 => "\x47",
     0x000000e6 => "\x9c",
     0x000000e7 => "\x48",
     0x000000e8 => "\x54",
     0x000000e9 => "\x51",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x8c",
     0x000000f1 => "\x6a",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\xcc",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x70",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xdc",
     0x000000fd => "\x8d",
     0x000000fe => "\x8e",
     0x000000ff => "\xdf",
     0x0000203e => "\xbc",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM285.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM285;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e1,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00f1,
     0x0024,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x0021,
     0x00a3,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0x00c3,
     0x00c5,
     0x00c7,
     0x00d1,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x00f0,
     0x00fd,
     0x00fe,
     0x00b1,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x00e6,
     0x00b8,
     0x00c6,
     0x00a4,
     0x00b5,
     0x203e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x00d0,
     0x00dd,
     0x00de,
     0x00ae,
     0x00a2,
     0x005b,
     0x00a5,
     0x00b7,
     0x00a9,
     0x00a7,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x005e,
     0x005d,
     0x007e,
     0x00a8,
     0x00b4,
     0x00d7,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00f3,
     0x00f5,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x00fc,
     0x00f9,
     0x00fa,
     0x00ff,
     0x005c,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x00d6,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x00dc,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xb1",
     "\x24",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\x21",
     "\xc2\xa3",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x91",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xb0",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc2\xb1",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc3\xa6",
     "\xc2\xb8",
     "\xc3\x86",
     "\xc2\xa4",
     "\xc2\xb5",
     "\xe2\x80\xbe",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc3\x90",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc2\xae",
     "\xc2\xa2",
     "\x5b",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\xc2\xa7",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\x5e",
     "\x5d",
     "\x7e",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xc3\x97",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbf",
     "\x5c",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\xc3\x96",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x4a",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\xb1",
     0x0000005c => "\xe0",
     0x0000005d => "\xbb",
     0x0000005e => "\xba",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\x4f",
     0x0000007d => "\xd0",
     0x0000007e => "\xbc",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\xb0",
     0x000000a3 => "\x5b",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\x6a",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xbd",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\x5f",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000b0 => "\x90",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x63",
     0x000000c5 => "\x67",
     0x000000c6 => "\x9e",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\xac",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\xec",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000dd => "\xad",
     0x000000de => "\xae",
     0x000000df => "\x59",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\x43",
     0x000000e5 => "\x47",
     0x000000e6 => "\x9c",
     0x000000e7 => "\x48",
     0x000000e8 => "\x54",
     0x000000e9 => "\x51",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x8c",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\xcc",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x70",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xdc",
     0x000000fd => "\x8d",
     0x000000fe => "\x8e",
     0x000000ff => "\xdf",
     0x0000203e => "\xa1",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM290.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM290;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x3002,
     0x300c,
     0x300d,
     0x3001,
     0x30fb,
     0x30f2,
     0x30a1,
     0x30a3,
     0x30a5,
     0x00a3,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0x30a7,
     0x30a9,
     0x30e3,
     0x30e5,
     0x30e7,
     0x30c3,
     0xfffd,
     0x30fc,
     0xfffd,
     0x0021,
     0x00a5,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x30a2,
     0x30a4,
     0x30a6,
     0x30a8,
     0x30aa,
     0x30ab,
     0x30ad,
     0x30af,
     0x30b1,
     0x30b3,
     0xfffd,
     0x30b5,
     0x30b7,
     0x30b9,
     0x30bb,
     0x30bd,
     0x30bf,
     0x30c1,
     0x30c4,
     0x30c6,
     0x30c8,
     0x30ca,
     0x30cb,
     0x30cc,
     0x30cd,
     0x30ce,
     0xfffd,
     0xfffd,
     0x30cf,
     0x30d2,
     0x30d5,
     0xfffd,
     0x203e,
     0x30d8,
     0x30db,
     0x30de,
     0x30df,
     0x30e0,
     0x30e1,
     0x30e2,
     0x30e4,
     0x30e6,
     0xfffd,
     0x30e8,
     0x30e9,
     0x30ea,
     0x30eb,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x30ec,
     0x30ed,
     0x30ef,
     0x30f3,
     0x309b,
     0x309c,
     0xfffd,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0024,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xe3\x80\x82",
     "\xe3\x80\x8c",
     "\xe3\x80\x8d",
     "\xe3\x80\x81",
     "\xe3\x83\xbb",
     "\xe3\x83\xb2",
     "\xe3\x82\xa1",
     "\xe3\x82\xa3",
     "\xe3\x82\xa5",
     "\xc2\xa3",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xe3\x82\xa7",
     "\xe3\x82\xa9",
     "\xe3\x83\xa3",
     "\xe3\x83\xa5",
     "\xe3\x83\xa7",
     "\xe3\x83\x83",
     "\xef\xbf\xbd",
     "\xe3\x83\xbc",
     "\xef\xbf\xbd",
     "\x21",
     "\xc2\xa5",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\xe3\x82\xa2",
     "\xe3\x82\xa4",
     "\xe3\x82\xa6",
     "\xe3\x82\xa8",
     "\xe3\x82\xaa",
     "\xe3\x82\xab",
     "\xe3\x82\xad",
     "\xe3\x82\xaf",
     "\xe3\x82\xb1",
     "\xe3\x82\xb3",
     "\xef\xbf\xbd",
     "\xe3\x82\xb5",
     "\xe3\x82\xb7",
     "\xe3\x82\xb9",
     "\xe3\x82\xbb",
     "\xe3\x82\xbd",
     "\xe3\x82\xbf",
     "\xe3\x83\x81",
     "\xe3\x83\x84",
     "\xe3\x83\x86",
     "\xe3\x83\x88",
     "\xe3\x83\x8a",
     "\xe3\x83\x8b",
     "\xe3\x83\x8c",
     "\xe3\x83\x8d",
     "\xe3\x83\x8e",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe3\x83\x8f",
     "\xe3\x83\x92",
     "\xe3\x83\x95",
     "\xef\xbf\xbd",
     "\xe2\x80\xbe",
     "\xe3\x83\x98",
     "\xe3\x83\x9b",
     "\xe3\x83\x9e",
     "\xe3\x83\x9f",
     "\xe3\x83\xa0",
     "\xe3\x83\xa1",
     "\xe3\x83\xa2",
     "\xe3\x83\xa4",
     "\xe3\x83\xa6",
     "\xef\xbf\xbd",
     "\xe3\x83\xa8",
     "\xe3\x83\xa9",
     "\xe3\x83\xaa",
     "\xe3\x83\xab",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe3\x83\xac",
     "\xe3\x83\xad",
     "\xe3\x83\xaf",
     "\xe3\x83\xb3",
     "\xe3\x82\x9b",
     "\xe3\x82\x9c",
     "\xef\xbf\xbd",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x24",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\xe0",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x0000007c => "\x4f",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a3 => "\x4a",
     0x000000a5 => "\x5b",
     0x000000a6 => "\x6a",
     0x000000ac => "\x5f",
     0x0000203e => "\xa1",
     0x00003001 => "\x44",
     0x00003002 => "\x41",
     0x0000300c => "\x42",
     0x0000300d => "\x43",
     0x0000309b => "\xbe",
     0x0000309c => "\xbf",
     0x000030a1 => "\x47",
     0x000030a2 => "\x81",
     0x000030a3 => "\x48",
     0x000030a4 => "\x82",
     0x000030a5 => "\x49",
     0x000030a6 => "\x83",
     0x000030a7 => "\x51",
     0x000030a8 => "\x84",
     0x000030a9 => "\x52",
     0x000030aa => "\x85",
     0x000030ab => "\x86",
     0x000030ad => "\x87",
     0x000030af => "\x88",
     0x000030b1 => "\x89",
     0x000030b3 => "\x8a",
     0x000030b5 => "\x8c",
     0x000030b7 => "\x8d",
     0x000030b9 => "\x8e",
     0x000030bb => "\x8f",
     0x000030bd => "\x90",
     0x000030bf => "\x91",
     0x000030c1 => "\x92",
     0x000030c3 => "\x56",
     0x000030c4 => "\x93",
     0x000030c6 => "\x94",
     0x000030c8 => "\x95",
     0x000030ca => "\x96",
     0x000030cb => "\x97",
     0x000030cc => "\x98",
     0x000030cd => "\x99",
     0x000030ce => "\x9a",
     0x000030cf => "\x9d",
     0x000030d2 => "\x9e",
     0x000030d5 => "\x9f",
     0x000030d8 => "\xa2",
     0x000030db => "\xa3",
     0x000030de => "\xa4",
     0x000030df => "\xa5",
     0x000030e0 => "\xa6",
     0x000030e1 => "\xa7",
     0x000030e2 => "\xa8",
     0x000030e3 => "\x53",
     0x000030e4 => "\xa9",
     0x000030e5 => "\x54",
     0x000030e6 => "\xaa",
     0x000030e7 => "\x55",
     0x000030e8 => "\xac",
     0x000030e9 => "\xad",
     0x000030ea => "\xae",
     0x000030eb => "\xaf",
     0x000030ec => "\xba",
     0x000030ed => "\xbb",
     0x000030ef => "\xbc",
     0x000030f2 => "\x46",
     0x000030f3 => "\xbd",
     0x000030fb => "\x45",
     0x000030fc => "\x58",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM297.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM297;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x00e4,
     0x0040,
     0x00e1,
     0x00e3,
     0x00e5,
     0x005c,
     0x00f1,
     0x00b0,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x007b,
     0x00ea,
     0x00eb,
     0x007d,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x00a7,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0x00c3,
     0x00c5,
     0x00c7,
     0x00d1,
     0x00f9,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x00b5,
     0x003a,
     0x00a3,
     0x00e0,
     0x0027,
     0x003d,
     0x0022,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x00f0,
     0x00fd,
     0x00fe,
     0x00b1,
     0x005b,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x00e6,
     0x00b8,
     0x00c6,
     0x00a4,
     0x0060,
     0x00a8,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x00d0,
     0x00dd,
     0x00de,
     0x00ae,
     0x00a2,
     0x0023,
     0x00a5,
     0x00b7,
     0x00a9,
     0x005d,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x00ac,
     0x007c,
     0x203e,
     0x007e,
     0x00b4,
     0x00d7,
     0x00e9,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00f3,
     0x00f5,
     0x00e8,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x00fc,
     0x00a6,
     0x00fa,
     0x00ff,
     0x00e7,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x00d6,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x00dc,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\x40",
     "\xc3\xa1",
     "\xc3\xa3",
     "\xc3\xa5",
     "\x5c",
     "\xc3\xb1",
     "\xc2\xb0",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\x7b",
     "\xc3\xaa",
     "\xc3\xab",
     "\x7d",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\xc2\xa7",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x91",
     "\xc3\xb9",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc2\xb5",
     "\x3a",
     "\xc2\xa3",
     "\xc3\xa0",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xb0",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc2\xb1",
     "\x5b",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc3\xa6",
     "\xc2\xb8",
     "\xc3\x86",
     "\xc2\xa4",
     "\x60",
     "\xc2\xa8",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc3\x90",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc2\xae",
     "\xc2\xa2",
     "\x23",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\x5d",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xac",
     "\x7c",
     "\xe2\x80\xbe",
     "\x7e",
     "\xc2\xb4",
     "\xc3\x97",
     "\xc3\xa9",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\xc3\xa8",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc2\xa6",
     "\xc3\xba",
     "\xc3\xbf",
     "\xc3\xa7",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\xc3\x96",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\xb1",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x44",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x90",
     0x0000005c => "\x48",
     0x0000005d => "\xb5",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\xa0",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\x51",
     0x0000007c => "\xbb",
     0x0000007d => "\x54",
     0x0000007e => "\xbd",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\xb0",
     0x000000a3 => "\x7b",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\xdd",
     0x000000a7 => "\x5a",
     0x000000a8 => "\xa1",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\xba",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000b0 => "\x4a",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\x79",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x63",
     0x000000c5 => "\x67",
     0x000000c6 => "\x9e",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\xac",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\xec",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000dd => "\xad",
     0x000000de => "\xae",
     0x000000df => "\x59",
     0x000000e0 => "\x7c",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\x43",
     0x000000e5 => "\x47",
     0x000000e6 => "\x9c",
     0x000000e7 => "\xe0",
     0x000000e8 => "\xd0",
     0x000000e9 => "\xc0",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x8c",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\xcc",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x70",
     0x000000f9 => "\x6a",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xdc",
     0x000000fd => "\x8d",
     0x000000fe => "\x8e",
     0x000000ff => "\xdf",
     0x0000203e => "\xbc",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM420.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM420;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x0651,
     0xfe7d,
     0x0640,
     0xfffd,
     0x0621,
     0x0622,
     0xfe82,
     0x0623,
     0x00a2,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0xfe84,
     0x0624,
     0xfffd,
     0xfffd,
     0x0626,
     0x0627,
     0xfe8e,
     0x0628,
     0xfe91,
     0x0021,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0x0629,
     0x062a,
     0xfe97,
     0x062b,
     0xfe9b,
     0x062c,
     0xfe9f,
     0x062d,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfea3,
     0x062e,
     0xfea7,
     0x062f,
     0x0630,
     0x0631,
     0x0632,
     0x0633,
     0xfeb3,
     0x060c,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0x0634,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0xfeb7,
     0x0635,
     0xfebb,
     0x0636,
     0xfebf,
     0x0637,
     0x0638,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0639,
     0xfeca,
     0xfecb,
     0xfecc,
     0x063a,
     0xfece,
     0xfecf,
     0x00f7,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfed0,
     0x0641,
     0xfed3,
     0x0642,
     0xfed7,
     0x0643,
     0xfedb,
     0x0644,
     0xfef5,
     0xfef6,
     0xfef7,
     0xfef8,
     0xfffd,
     0xfffd,
     0xfefb,
     0xfefc,
     0xfedf,
     0x0645,
     0xfee3,
     0x0646,
     0xfee7,
     0x0647,
     0x061b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0xfeeb,
     0xfffd,
     0xfeec,
     0xfffd,
     0x0648,
     0x061f,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0649,
     0xfef0,
     0x064a,
     0xfef2,
     0xfef3,
     0x0660,
     0x00d7,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x0661,
     0x0662,
     0xfffd,
     0x0663,
     0x0664,
     0x0665,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0x0666,
     0x0667,
     0x0668,
     0x0669,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xd9\x91",
     "\xef\xb9\xbd",
     "\xd9\x80",
     "\xef\xbf\xbd",
     "\xd8\xa1",
     "\xd8\xa2",
     "\xef\xba\x82",
     "\xd8\xa3",
     "\xc2\xa2",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xef\xba\x84",
     "\xd8\xa4",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd8\xa6",
     "\xd8\xa7",
     "\xef\xba\x8e",
     "\xd8\xa8",
     "\xef\xba\x91",
     "\x21",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xd8\xa9",
     "\xd8\xaa",
     "\xef\xba\x97",
     "\xd8\xab",
     "\xef\xba\x9b",
     "\xd8\xac",
     "\xef\xba\x9f",
     "\xd8\xad",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xba\xa3",
     "\xd8\xae",
     "\xef\xba\xa7",
     "\xd8\xaf",
     "\xd8\xb0",
     "\xd8\xb1",
     "\xd8\xb2",
     "\xd8\xb3",
     "\xef\xba\xb3",
     "\xd8\x8c",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xd8\xb4",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xef\xba\xb7",
     "\xd8\xb5",
     "\xef\xba\xbb",
     "\xd8\xb6",
     "\xef\xba\xbf",
     "\xd8\xb7",
     "\xd8\xb8",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xd8\xb9",
     "\xef\xbb\x8a",
     "\xef\xbb\x8b",
     "\xef\xbb\x8c",
     "\xd8\xba",
     "\xef\xbb\x8e",
     "\xef\xbb\x8f",
     "\xc3\xb7",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbb\x90",
     "\xd9\x81",
     "\xef\xbb\x93",
     "\xd9\x82",
     "\xef\xbb\x97",
     "\xd9\x83",
     "\xef\xbb\x9b",
     "\xd9\x84",
     "\xef\xbb\xb5",
     "\xef\xbb\xb6",
     "\xef\xbb\xb7",
     "\xef\xbb\xb8",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbb\xbb",
     "\xef\xbb\xbc",
     "\xef\xbb\x9f",
     "\xd9\x85",
     "\xef\xbb\xa3",
     "\xd9\x86",
     "\xef\xbb\xa7",
     "\xd9\x87",
     "\xd8\x9b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xef\xbb\xab",
     "\xef\xbf\xbd",
     "\xef\xbb\xac",
     "\xef\xbf\xbd",
     "\xd9\x88",
     "\xd8\x9f",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xd9\x89",
     "\xef\xbb\xb0",
     "\xd9\x8a",
     "\xef\xbb\xb2",
     "\xef\xbb\xb3",
     "\xd9\xa0",
     "\xc3\x97",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xd9\xa1",
     "\xd9\xa2",
     "\xef\xbf\xbd",
     "\xd9\xa3",
     "\xd9\xa4",
     "\xd9\xa5",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xd9\xa6",
     "\xd9\xa7",
     "\xd9\xa8",
     "\xd9\xa9",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005f => "\x6d",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007c => "\x4f",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a2 => "\x4a",
     0x000000a6 => "\x6a",
     0x000000ac => "\x5f",
     0x000000ad => "\xca",
     0x000000d7 => "\xe0",
     0x000000f7 => "\xa1",
     0x0000060c => "\x79",
     0x0000061b => "\xc0",
     0x0000061f => "\xd0",
     0x00000621 => "\x46",
     0x00000622 => "\x47",
     0x00000623 => "\x49",
     0x00000624 => "\x52",
     0x00000626 => "\x55",
     0x00000627 => "\x56",
     0x00000628 => "\x58",
     0x00000629 => "\x62",
     0x0000062a => "\x63",
     0x0000062b => "\x65",
     0x0000062c => "\x67",
     0x0000062d => "\x69",
     0x0000062e => "\x71",
     0x0000062f => "\x73",
     0x00000630 => "\x74",
     0x00000631 => "\x75",
     0x00000632 => "\x76",
     0x00000633 => "\x77",
     0x00000634 => "\x80",
     0x00000635 => "\x8b",
     0x00000636 => "\x8d",
     0x00000637 => "\x8f",
     0x00000638 => "\x90",
     0x00000639 => "\x9a",
     0x0000063a => "\x9e",
     0x00000640 => "\x44",
     0x00000641 => "\xab",
     0x00000642 => "\xad",
     0x00000643 => "\xaf",
     0x00000644 => "\xb1",
     0x00000645 => "\xbb",
     0x00000646 => "\xbd",
     0x00000647 => "\xbf",
     0x00000648 => "\xcf",
     0x00000649 => "\xda",
     0x0000064a => "\xdc",
     0x00000651 => "\x42",
     0x00000660 => "\xdf",
     0x00000661 => "\xea",
     0x00000662 => "\xeb",
     0x00000663 => "\xed",
     0x00000664 => "\xee",
     0x00000665 => "\xef",
     0x00000666 => "\xfb",
     0x00000667 => "\xfc",
     0x00000668 => "\xfd",
     0x00000669 => "\xfe",
     0x0000fe7d => "\x43",
     0x0000fe82 => "\x48",
     0x0000fe84 => "\x51",
     0x0000fe8e => "\x57",
     0x0000fe91 => "\x59",
     0x0000fe97 => "\x64",
     0x0000fe9b => "\x66",
     0x0000fe9f => "\x68",
     0x0000fea3 => "\x70",
     0x0000fea7 => "\x72",
     0x0000feb3 => "\x78",
     0x0000feb7 => "\x8a",
     0x0000febb => "\x8c",
     0x0000febf => "\x8e",
     0x0000feca => "\x9b",
     0x0000fecb => "\x9c",
     0x0000fecc => "\x9d",
     0x0000fece => "\x9f",
     0x0000fecf => "\xa0",
     0x0000fed0 => "\xaa",
     0x0000fed3 => "\xac",
     0x0000fed7 => "\xae",
     0x0000fedb => "\xb0",
     0x0000fedf => "\xba",
     0x0000fee3 => "\xbc",
     0x0000fee7 => "\xbe",
     0x0000feeb => "\xcb",
     0x0000feec => "\xcd",
     0x0000fef0 => "\xdb",
     0x0000fef2 => "\xdd",
     0x0000fef3 => "\xde",
     0x0000fef5 => "\xb2",
     0x0000fef6 => "\xb3",
     0x0000fef7 => "\xb4",
     0x0000fef8 => "\xb5",
     0x0000fefb => "\xb8",
     0x0000fefc => "\xb9",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\xd0"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM423.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM423;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x0391,
     0x0392,
     0x0393,
     0x0394,
     0x0395,
     0x0396,
     0x0397,
     0x0398,
     0x0399,
     0x005b,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x039a,
     0x039b,
     0x039c,
     0x039d,
     0x039e,
     0x039f,
     0x03a0,
     0x03a1,
     0x03a3,
     0x005d,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x03a4,
     0x03a5,
     0x03a6,
     0x03a7,
     0x03a8,
     0x03a9,
     0xfffd,
     0xfffd,
     0xfffd,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0x0386,
     0x0388,
     0x0389,
     0xfffd,
     0x038a,
     0x038c,
     0x038e,
     0x038f,
     0x0060,
     0x003a,
     0x00a3,
     0x00a7,
     0x0027,
     0x003d,
     0x0022,
     0x00c4,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x03b1,
     0x03b2,
     0x03b3,
     0x03b4,
     0x03b5,
     0x03b6,
     0x00d6,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x03b7,
     0x03b8,
     0x03b9,
     0x03ba,
     0x03bb,
     0x03bc,
     0x00dc,
     0x00a8,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x03bd,
     0x03be,
     0x03bf,
     0x03c0,
     0x03c1,
     0x03c2,
     0xfffd,
     0x03ac,
     0x03ad,
     0x03ae,
     0x03ca,
     0x03af,
     0x03cc,
     0x03cd,
     0x03cb,
     0x03ce,
     0x03c3,
     0x03c4,
     0x03c5,
     0x03c6,
     0x03c7,
     0x03c8,
     0x00b8,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0xfffd,
     0x03c9,
     0x00c2,
     0x00e0,
     0x00e4,
     0x00ea,
     0x00b4,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b1,
     0x00e9,
     0x00e8,
     0x00eb,
     0x00ee,
     0x00ef,
     0x00b0,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00bd,
     0x00f6,
     0x00f4,
     0x00fb,
     0x00f9,
     0x00fc,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00ff,
     0x00e7,
     0x00c7,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xce\x91",
     "\xce\x92",
     "\xce\x93",
     "\xce\x94",
     "\xce\x95",
     "\xce\x96",
     "\xce\x97",
     "\xce\x98",
     "\xce\x99",
     "\x5b",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xce\x9a",
     "\xce\x9b",
     "\xce\x9c",
     "\xce\x9d",
     "\xce\x9e",
     "\xce\x9f",
     "\xce\xa0",
     "\xce\xa1",
     "\xce\xa3",
     "\x5d",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xce\xa4",
     "\xce\xa5",
     "\xce\xa6",
     "\xce\xa7",
     "\xce\xa8",
     "\xce\xa9",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xce\x86",
     "\xce\x88",
     "\xce\x89",
     "\xef\xbf\xbd",
     "\xce\x8a",
     "\xce\x8c",
     "\xce\x8e",
     "\xce\x8f",
     "\x60",
     "\x3a",
     "\xc2\xa3",
     "\xc2\xa7",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x84",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\xb3",
     "\xce\xb4",
     "\xce\xb5",
     "\xce\xb6",
     "\xc3\x96",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xce\xb7",
     "\xce\xb8",
     "\xce\xb9",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xc3\x9c",
     "\xc2\xa8",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xce\xbd",
     "\xce\xbe",
     "\xce\xbf",
     "\xcf\x80",
     "\xcf\x81",
     "\xcf\x82",
     "\xef\xbf\xbd",
     "\xce\xac",
     "\xce\xad",
     "\xce\xae",
     "\xcf\x8a",
     "\xce\xaf",
     "\xcf\x8c",
     "\xcf\x8d",
     "\xcf\x8b",
     "\xcf\x8e",
     "\xcf\x83",
     "\xcf\x84",
     "\xcf\x85",
     "\xcf\x86",
     "\xcf\x87",
     "\xcf\x88",
     "\xc2\xb8",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xef\xbf\xbd",
     "\xcf\x89",
     "\xc3\x82",
     "\xc3\xa0",
     "\xc3\xa4",
     "\xc3\xaa",
     "\xc2\xb4",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb1",
     "\xc3\xa9",
     "\xc3\xa8",
     "\xc3\xab",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc2\xb0",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xbd",
     "\xc3\xb6",
     "\xc3\xb4",
     "\xc3\xbb",
     "\xc3\xb9",
     "\xc3\xbc",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc3\xbf",
     "\xc3\xa7",
     "\xc3\x87",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x4a",
     0x0000005d => "\x5a",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a3 => "\x7b",
     0x000000a7 => "\x7c",
     0x000000a8 => "\xa1",
     0x000000b0 => "\xe0",
     0x000000b1 => "\xda",
     0x000000b4 => "\xd0",
     0x000000b8 => "\xc0",
     0x000000bd => "\xea",
     0x000000c2 => "\xcc",
     0x000000c4 => "\x80",
     0x000000c7 => "\xfc",
     0x000000d6 => "\x90",
     0x000000dc => "\xa0",
     0x000000e0 => "\xcd",
     0x000000e4 => "\xce",
     0x000000e7 => "\xfb",
     0x000000e8 => "\xdc",
     0x000000e9 => "\xdb",
     0x000000ea => "\xcf",
     0x000000eb => "\xdd",
     0x000000ee => "\xde",
     0x000000ef => "\xdf",
     0x000000f4 => "\xec",
     0x000000f6 => "\xeb",
     0x000000f9 => "\xee",
     0x000000fb => "\xed",
     0x000000fc => "\xef",
     0x000000ff => "\xfa",
     0x00000386 => "\x71",
     0x00000388 => "\x72",
     0x00000389 => "\x73",
     0x0000038a => "\x75",
     0x0000038c => "\x76",
     0x0000038e => "\x77",
     0x0000038f => "\x78",
     0x00000391 => "\x41",
     0x00000392 => "\x42",
     0x00000393 => "\x43",
     0x00000394 => "\x44",
     0x00000395 => "\x45",
     0x00000396 => "\x46",
     0x00000397 => "\x47",
     0x00000398 => "\x48",
     0x00000399 => "\x49",
     0x0000039a => "\x51",
     0x0000039b => "\x52",
     0x0000039c => "\x53",
     0x0000039d => "\x54",
     0x0000039e => "\x55",
     0x0000039f => "\x56",
     0x000003a0 => "\x57",
     0x000003a1 => "\x58",
     0x000003a3 => "\x59",
     0x000003a4 => "\x62",
     0x000003a5 => "\x63",
     0x000003a6 => "\x64",
     0x000003a7 => "\x65",
     0x000003a8 => "\x66",
     0x000003a9 => "\x67",
     0x000003ac => "\xb1",
     0x000003ad => "\xb2",
     0x000003ae => "\xb3",
     0x000003af => "\xb5",
     0x000003b1 => "\x8a",
     0x000003b2 => "\x8b",
     0x000003b3 => "\x8c",
     0x000003b4 => "\x8d",
     0x000003b5 => "\x8e",
     0x000003b6 => "\x8f",
     0x000003b7 => "\x9a",
     0x000003b8 => "\x9b",
     0x000003b9 => "\x9c",
     0x000003ba => "\x9d",
     0x000003bb => "\x9e",
     0x000003bc => "\x9f",
     0x000003bd => "\xaa",
     0x000003be => "\xab",
     0x000003bf => "\xac",
     0x000003c0 => "\xad",
     0x000003c1 => "\xae",
     0x000003c2 => "\xaf",
     0x000003c3 => "\xba",
     0x000003c4 => "\xbb",
     0x000003c5 => "\xbc",
     0x000003c6 => "\xbd",
     0x000003c7 => "\xbe",
     0x000003c8 => "\xbf",
     0x000003c9 => "\xcb",
     0x000003ca => "\xb4",
     0x000003cb => "\xb8",
     0x000003cc => "\xb6",
     0x000003cd => "\xb7",
     0x000003ce => "\xb9",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM424.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM424;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x05d0,
     0x05d1,
     0x05d2,
     0x05d3,
     0x05d4,
     0x05d5,
     0x05d6,
     0x05d7,
     0x05d8,
     0x00a2,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x007c,
     0x0026,
     0x05d9,
     0x05da,
     0x05db,
     0x05dc,
     0x05dd,
     0x05de,
     0x05df,
     0x05e0,
     0x05e1,
     0x0021,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x00ac,
     0x002d,
     0x002f,
     0x05e2,
     0x05e3,
     0x05e4,
     0x05e5,
     0x05e6,
     0x05e7,
     0x05e8,
     0x05e9,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0x05ea,
     0xfffd,
     0xfffd,
     0x00a0,
     0xfffd,
     0xfffd,
     0xfffd,
     0x21d4,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00b8,
     0xfffd,
     0x00a4,
     0x00b5,
     0x007e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00ae,
     0x005e,
     0x00a3,
     0x00a5,
     0x00b7,
     0x00a9,
     0x00a7,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x005b,
     0x005d,
     0x203e,
     0x00a8,
     0x00b4,
     0x00d7,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005c,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xd7\x90",
     "\xd7\x91",
     "\xd7\x92",
     "\xd7\x93",
     "\xd7\x94",
     "\xd7\x95",
     "\xd7\x96",
     "\xd7\x97",
     "\xd7\x98",
     "\xc2\xa2",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x7c",
     "\x26",
     "\xd7\x99",
     "\xd7\x9a",
     "\xd7\x9b",
     "\xd7\x9c",
     "\xd7\x9d",
     "\xd7\x9e",
     "\xd7\x9f",
     "\xd7\xa0",
     "\xd7\xa1",
     "\x21",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc2\xac",
     "\x2d",
     "\x2f",
     "\xd7\xa2",
     "\xd7\xa3",
     "\xd7\xa4",
     "\xd7\xa5",
     "\xd7\xa6",
     "\xd7\xa7",
     "\xd7\xa8",
     "\xd7\xa9",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xd7\xaa",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa0",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x87\x94",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xb8",
     "\xef\xbf\xbd",
     "\xc2\xa4",
     "\xc2\xb5",
     "\x7e",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xae",
     "\x5e",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\xc2\xa7",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\x5b",
     "\x5d",
     "\xe2\x80\xbe",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xc3\x97",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5c",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x5a",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\xba",
     0x0000005c => "\xe0",
     0x0000005d => "\xbb",
     0x0000005e => "\xb0",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\x4f",
     0x0000007d => "\xd0",
     0x0000007e => "\xa1",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x74",
     0x000000a2 => "\x4a",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\x6a",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xbd",
     0x000000a9 => "\xb4",
     0x000000ab => "\x8a",
     0x000000ac => "\x5f",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000b0 => "\x90",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000d7 => "\xbf",
     0x000000f7 => "\xe1",
     0x000005d0 => "\x41",
     0x000005d1 => "\x42",
     0x000005d2 => "\x43",
     0x000005d3 => "\x44",
     0x000005d4 => "\x45",
     0x000005d5 => "\x46",
     0x000005d6 => "\x47",
     0x000005d7 => "\x48",
     0x000005d8 => "\x49",
     0x000005d9 => "\x51",
     0x000005da => "\x52",
     0x000005db => "\x53",
     0x000005dc => "\x54",
     0x000005dd => "\x55",
     0x000005de => "\x56",
     0x000005df => "\x57",
     0x000005e0 => "\x58",
     0x000005e1 => "\x59",
     0x000005e2 => "\x62",
     0x000005e3 => "\x63",
     0x000005e4 => "\x64",
     0x000005e5 => "\x65",
     0x000005e6 => "\x66",
     0x000005e7 => "\x67",
     0x000005e8 => "\x68",
     0x000005e9 => "\x69",
     0x000005ea => "\x71",
     0x0000203e => "\xbc",
     0x000021d4 => "\x78",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM437.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM437;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e5,
     0x00e7,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ef,
     0x00ee,
     0x00ec,
     0x00c4,
     0x00c5,
     0x00c9,
     0x00e6,
     0x00c6,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00fb,
     0x00f9,
     0x00ff,
     0x00d6,
     0x00dc,
     0x00a2,
     0x00a3,
     0x00a5,
     0x20a7,
     0x0192,
     0x00e1,
     0x00ed,
     0x00f3,
     0x00fa,
     0x00f1,
     0x00d1,
     0x00aa,
     0x00ba,
     0x00bf,
     0x2310,
     0x00ac,
     0x00bd,
     0x00bc,
     0x00a1,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x2561,
     0x2562,
     0x2556,
     0x2555,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x255c,
     0x255b,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x255e,
     0x255f,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x2567,
     0x2568,
     0x2564,
     0x2565,
     0x2559,
     0x2558,
     0x2552,
     0x2553,
     0x256b,
     0x256a,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x258c,
     0x2590,
     0x2580,
     0x03b1,
     0x00df,
     0x0393,
     0x03c0,
     0x03a3,
     0x03c3,
     0x00b5,
     0x03c4,
     0x03a6,
     0x0398,
     0x03a9,
     0x03b4,
     0x221e,
     0x03c6,
     0x03b5,
     0x2229,
     0x2261,
     0x00b1,
     0x2265,
     0x2264,
     0x2320,
     0x2321,
     0x00f7,
     0x2248,
     0x00b0,
     0x2219,
     0x00b7,
     0x221a,
     0x207f,
     0x00b2,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xaf",
     "\xc3\xae",
     "\xc3\xac",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x89",
     "\xc3\xa6",
     "\xc3\x86",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xbb",
     "\xc3\xb9",
     "\xc3\xbf",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xe2\x82\xa7",
     "\xc6\x92",
     "\xc3\xa1",
     "\xc3\xad",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc3\xb1",
     "\xc3\x91",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc2\xbf",
     "\xe2\x8c\x90",
     "\xc2\xac",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xc2\xa1",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xe2\x95\xa1",
     "\xe2\x95\xa2",
     "\xe2\x95\x96",
     "\xe2\x95\x95",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xe2\x95\x9c",
     "\xe2\x95\x9b",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xe2\x95\x9e",
     "\xe2\x95\x9f",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xe2\x95\xa7",
     "\xe2\x95\xa8",
     "\xe2\x95\xa4",
     "\xe2\x95\xa5",
     "\xe2\x95\x99",
     "\xe2\x95\x98",
     "\xe2\x95\x92",
     "\xe2\x95\x93",
     "\xe2\x95\xab",
     "\xe2\x95\xaa",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xe2\x96\x8c",
     "\xe2\x96\x90",
     "\xe2\x96\x80",
     "\xce\xb1",
     "\xc3\x9f",
     "\xce\x93",
     "\xcf\x80",
     "\xce\xa3",
     "\xcf\x83",
     "\xc2\xb5",
     "\xcf\x84",
     "\xce\xa6",
     "\xce\x98",
     "\xce\xa9",
     "\xce\xb4",
     "\xe2\x88\x9e",
     "\xcf\x86",
     "\xce\xb5",
     "\xe2\x88\xa9",
     "\xe2\x89\xa1",
     "\xc2\xb1",
     "\xe2\x89\xa5",
     "\xe2\x89\xa4",
     "\xe2\x8c\xa0",
     "\xe2\x8c\xa1",
     "\xc3\xb7",
     "\xe2\x89\x88",
     "\xc2\xb0",
     "\xe2\x88\x99",
     "\xc2\xb7",
     "\xe2\x88\x9a",
     "\xe2\x81\xbf",
     "\xc2\xb2",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a1 => "\xad",
     0x000000a2 => "\x9b",
     0x000000a3 => "\x9c",
     0x000000a5 => "\x9d",
     0x000000aa => "\xa6",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b2 => "\xfd",
     0x000000b5 => "\xe6",
     0x000000b7 => "\xfa",
     0x000000ba => "\xa7",
     0x000000bb => "\xaf",
     0x000000bc => "\xac",
     0x000000bd => "\xab",
     0x000000bf => "\xa8",
     0x000000c4 => "\x8e",
     0x000000c5 => "\x8f",
     0x000000c6 => "\x92",
     0x000000c7 => "\x80",
     0x000000c9 => "\x90",
     0x000000d1 => "\xa5",
     0x000000d6 => "\x99",
     0x000000dc => "\x9a",
     0x000000df => "\xe1",
     0x000000e0 => "\x85",
     0x000000e1 => "\xa0",
     0x000000e2 => "\x83",
     0x000000e4 => "\x84",
     0x000000e5 => "\x86",
     0x000000e6 => "\x91",
     0x000000e7 => "\x87",
     0x000000e8 => "\x8a",
     0x000000e9 => "\x82",
     0x000000ea => "\x88",
     0x000000eb => "\x89",
     0x000000ec => "\x8d",
     0x000000ed => "\xa1",
     0x000000ee => "\x8c",
     0x000000ef => "\x8b",
     0x000000f1 => "\xa4",
     0x000000f2 => "\x95",
     0x000000f3 => "\xa2",
     0x000000f4 => "\x93",
     0x000000f6 => "\x94",
     0x000000f7 => "\xf6",
     0x000000f9 => "\x97",
     0x000000fa => "\xa3",
     0x000000fb => "\x96",
     0x000000fc => "\x81",
     0x000000ff => "\x98",
     0x00000192 => "\x9f",
     0x00000393 => "\xe2",
     0x00000398 => "\xe9",
     0x000003a3 => "\xe4",
     0x000003a6 => "\xe8",
     0x000003a9 => "\xea",
     0x000003b1 => "\xe0",
     0x000003b4 => "\xeb",
     0x000003b5 => "\xee",
     0x000003c0 => "\xe3",
     0x000003c3 => "\xe5",
     0x000003c4 => "\xe7",
     0x000003c6 => "\xed",
     0x0000207f => "\xfc",
     0x000020a7 => "\x9e",
     0x00002219 => "\xf9",
     0x0000221a => "\xfb",
     0x0000221e => "\xec",
     0x00002229 => "\xef",
     0x00002248 => "\xf7",
     0x00002261 => "\xf0",
     0x00002264 => "\xf3",
     0x00002265 => "\xf2",
     0x00002310 => "\xa9",
     0x00002320 => "\xf4",
     0x00002321 => "\xf5",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002552 => "\xd5",
     0x00002553 => "\xd6",
     0x00002554 => "\xc9",
     0x00002555 => "\xb8",
     0x00002556 => "\xb7",
     0x00002557 => "\xbb",
     0x00002558 => "\xd4",
     0x00002559 => "\xd3",
     0x0000255a => "\xc8",
     0x0000255b => "\xbe",
     0x0000255c => "\xbd",
     0x0000255d => "\xbc",
     0x0000255e => "\xc6",
     0x0000255f => "\xc7",
     0x00002560 => "\xcc",
     0x00002561 => "\xb5",
     0x00002562 => "\xb6",
     0x00002563 => "\xb9",
     0x00002564 => "\xd1",
     0x00002565 => "\xd2",
     0x00002566 => "\xcb",
     0x00002567 => "\xcf",
     0x00002568 => "\xd0",
     0x00002569 => "\xca",
     0x0000256a => "\xd8",
     0x0000256b => "\xd7",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x0000258c => "\xdd",
     0x00002590 => "\xde",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM500.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM500;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e1,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00f1,
     0x005b,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x005d,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0x00c3,
     0x00c5,
     0x00c7,
     0x00d1,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x00f0,
     0x00fd,
     0x00fe,
     0x00b1,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x00e6,
     0x00b8,
     0x00c6,
     0x00a4,
     0x00b5,
     0x007e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x00d0,
     0x00dd,
     0x00de,
     0x00ae,
     0x00a2,
     0x00a3,
     0x00a5,
     0x00b7,
     0x00a9,
     0x00a7,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x00ac,
     0x007c,
     0x00af,
     0x00a8,
     0x00b4,
     0x00d7,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00f3,
     0x00f5,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x00fc,
     0x00f9,
     0x00fa,
     0x00ff,
     0x005c,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x00d6,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x00dc,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xb1",
     "\x5b",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\x5d",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x91",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\xc3\xb0",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc2\xb1",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc3\xa6",
     "\xc2\xb8",
     "\xc3\x86",
     "\xc2\xa4",
     "\xc2\xb5",
     "\x7e",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\xc3\x90",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc2\xae",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\xc2\xa7",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xac",
     "\x7c",
     "\xc2\xaf",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xc3\x97",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbf",
     "\x5c",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\xc3\x96",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x4a",
     0x0000005c => "\xe0",
     0x0000005d => "\x5a",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\xbb",
     0x0000007d => "\xd0",
     0x0000007e => "\xa1",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\xb0",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\x6a",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xbd",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\xba",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000af => "\xbc",
     0x000000b0 => "\x90",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x63",
     0x000000c5 => "\x67",
     0x000000c6 => "\x9e",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\xac",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\xec",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000dd => "\xad",
     0x000000de => "\xae",
     0x000000df => "\x59",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\x43",
     0x000000e5 => "\x47",
     0x000000e6 => "\x9c",
     0x000000e7 => "\x48",
     0x000000e8 => "\x54",
     0x000000e9 => "\x51",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x8c",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\xcc",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x70",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xdc",
     0x000000fd => "\x8d",
     0x000000fe => "\x8e",
     0x000000ff => "\xdf",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM850.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM850;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e5,
     0x00e7,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ef,
     0x00ee,
     0x00ec,
     0x00c4,
     0x00c5,
     0x00c9,
     0x00e6,
     0x00c6,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00fb,
     0x00f9,
     0x00ff,
     0x00d6,
     0x00dc,
     0x00f8,
     0x00a3,
     0x00d8,
     0x00d7,
     0x0192,
     0x00e1,
     0x00ed,
     0x00f3,
     0x00fa,
     0x00f1,
     0x00d1,
     0x00aa,
     0x00ba,
     0x00bf,
     0x00ae,
     0x00ac,
     0x00bd,
     0x00bc,
     0x00a1,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x00c1,
     0x00c2,
     0x00c0,
     0x00a9,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x00a2,
     0x00a5,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x00e3,
     0x00c3,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x00a4,
     0x00f0,
     0x00d0,
     0x00ca,
     0x00cb,
     0x00c8,
     0x0131,
     0x00cd,
     0x00ce,
     0x00cf,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x00a6,
     0x00cc,
     0x2580,
     0x00d3,
     0x00df,
     0x00d4,
     0x00d2,
     0x00f5,
     0x00d5,
     0x00b5,
     0x00fe,
     0x00de,
     0x00da,
     0x00db,
     0x00d9,
     0x00fd,
     0x00dd,
     0x00af,
     0x00b4,
     0x00ad,
     0x00b1,
     0x2017,
     0x00be,
     0x00b6,
     0x00a7,
     0x00f7,
     0x00b8,
     0x00b0,
     0x00a8,
     0x00b7,
     0x00b9,
     0x00b3,
     0x00b2,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xaf",
     "\xc3\xae",
     "\xc3\xac",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x89",
     "\xc3\xa6",
     "\xc3\x86",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xbb",
     "\xc3\xb9",
     "\xc3\xbf",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xb8",
     "\xc2\xa3",
     "\xc3\x98",
     "\xc3\x97",
     "\xc6\x92",
     "\xc3\xa1",
     "\xc3\xad",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc3\xb1",
     "\xc3\x91",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc2\xbf",
     "\xc2\xae",
     "\xc2\xac",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xc2\xa1",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x80",
     "\xc2\xa9",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xc2\xa2",
     "\xc2\xa5",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xc3\xa3",
     "\xc3\x83",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xc2\xa4",
     "\xc3\xb0",
     "\xc3\x90",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc4\xb1",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xc2\xa6",
     "\xc3\x8c",
     "\xe2\x96\x80",
     "\xc3\x93",
     "\xc3\x9f",
     "\xc3\x94",
     "\xc3\x92",
     "\xc3\xb5",
     "\xc3\x95",
     "\xc2\xb5",
     "\xc3\xbe",
     "\xc3\x9e",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x99",
     "\xc3\xbd",
     "\xc3\x9d",
     "\xc2\xaf",
     "\xc2\xb4",
     "\xc2\xad",
     "\xc2\xb1",
     "\xe2\x80\x97",
     "\xc2\xbe",
     "\xc2\xb6",
     "\xc2\xa7",
     "\xc3\xb7",
     "\xc2\xb8",
     "\xc2\xb0",
     "\xc2\xa8",
     "\xc2\xb7",
     "\xc2\xb9",
     "\xc2\xb3",
     "\xc2\xb2",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a1 => "\xad",
     0x000000a2 => "\xbd",
     0x000000a3 => "\x9c",
     0x000000a4 => "\xcf",
     0x000000a5 => "\xbe",
     0x000000a6 => "\xdd",
     0x000000a7 => "\xf5",
     0x000000a8 => "\xf9",
     0x000000a9 => "\xb8",
     0x000000aa => "\xa6",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000ad => "\xf0",
     0x000000ae => "\xa9",
     0x000000af => "\xee",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b2 => "\xfd",
     0x000000b3 => "\xfc",
     0x000000b4 => "\xef",
     0x000000b5 => "\xe6",
     0x000000b6 => "\xf4",
     0x000000b7 => "\xfa",
     0x000000b8 => "\xf7",
     0x000000b9 => "\xfb",
     0x000000ba => "\xa7",
     0x000000bb => "\xaf",
     0x000000bc => "\xac",
     0x000000bd => "\xab",
     0x000000be => "\xf3",
     0x000000bf => "\xa8",
     0x000000c0 => "\xb7",
     0x000000c1 => "\xb5",
     0x000000c2 => "\xb6",
     0x000000c3 => "\xc7",
     0x000000c4 => "\x8e",
     0x000000c5 => "\x8f",
     0x000000c6 => "\x92",
     0x000000c7 => "\x80",
     0x000000c8 => "\xd4",
     0x000000c9 => "\x90",
     0x000000ca => "\xd2",
     0x000000cb => "\xd3",
     0x000000cc => "\xde",
     0x000000cd => "\xd6",
     0x000000ce => "\xd7",
     0x000000cf => "\xd8",
     0x000000d0 => "\xd1",
     0x000000d1 => "\xa5",
     0x000000d2 => "\xe3",
     0x000000d3 => "\xe0",
     0x000000d4 => "\xe2",
     0x000000d5 => "\xe5",
     0x000000d6 => "\x99",
     0x000000d7 => "\x9e",
     0x000000d8 => "\x9d",
     0x000000d9 => "\xeb",
     0x000000da => "\xe9",
     0x000000db => "\xea",
     0x000000dc => "\x9a",
     0x000000dd => "\xed",
     0x000000de => "\xe8",
     0x000000df => "\xe1",
     0x000000e0 => "\x85",
     0x000000e1 => "\xa0",
     0x000000e2 => "\x83",
     0x000000e3 => "\xc6",
     0x000000e4 => "\x84",
     0x000000e5 => "\x86",
     0x000000e6 => "\x91",
     0x000000e7 => "\x87",
     0x000000e8 => "\x8a",
     0x000000e9 => "\x82",
     0x000000ea => "\x88",
     0x000000eb => "\x89",
     0x000000ec => "\x8d",
     0x000000ed => "\xa1",
     0x000000ee => "\x8c",
     0x000000ef => "\x8b",
     0x000000f0 => "\xd0",
     0x000000f1 => "\xa4",
     0x000000f2 => "\x95",
     0x000000f3 => "\xa2",
     0x000000f4 => "\x93",
     0x000000f5 => "\xe4",
     0x000000f6 => "\x94",
     0x000000f7 => "\xf6",
     0x000000f8 => "\x9b",
     0x000000f9 => "\x97",
     0x000000fa => "\xa3",
     0x000000fb => "\x96",
     0x000000fc => "\x81",
     0x000000fd => "\xec",
     0x000000fe => "\xe7",
     0x000000ff => "\x98",
     0x00000131 => "\xd5",
     0x00000192 => "\x9f",
     0x00002017 => "\xf2",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002554 => "\xc9",
     0x00002557 => "\xbb",
     0x0000255a => "\xc8",
     0x0000255d => "\xbc",
     0x00002560 => "\xcc",
     0x00002563 => "\xb9",
     0x00002566 => "\xcb",
     0x00002569 => "\xca",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM851.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM851;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00e4,
     0x00e0,
     0x0386,
     0x00e7,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ef,
     0x00ee,
     0x0388,
     0x00c4,
     0x0389,
     0x038a,
     0xfffd,
     0x038c,
     0x00f4,
     0x00f6,
     0x038e,
     0x00fb,
     0x00f9,
     0x038f,
     0x00d6,
     0x00dc,
     0x03ac,
     0x00a3,
     0x03ad,
     0x03ae,
     0x03af,
     0x03ca,
     0x0390,
     0x03cc,
     0x03cd,
     0x0391,
     0x0392,
     0x0393,
     0x0394,
     0x0395,
     0x0396,
     0x0397,
     0x00bd,
     0x0398,
     0x0399,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x039a,
     0x039b,
     0x039d,
     0x039c,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x039e,
     0x039f,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x03a0,
     0x03a1,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x03a3,
     0x03a4,
     0x03a5,
     0x03a6,
     0x03a7,
     0x03a8,
     0x03a9,
     0x03b1,
     0x03b2,
     0x03b3,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x03b4,
     0x03b5,
     0x2580,
     0x03b6,
     0x03b7,
     0x03b8,
     0x03b9,
     0x03ba,
     0x03bb,
     0x03bc,
     0x03bd,
     0x03be,
     0x03bf,
     0x03c0,
     0x03c1,
     0x03c3,
     0x03c2,
     0x03c4,
     0x00b4,
     0x00ad,
     0x00b1,
     0x03c5,
     0x03c6,
     0x03c7,
     0x00a7,
     0x03c8,
     0x02db,
     0x00b0,
     0x00a8,
     0x03c9,
     0x03cb,
     0x03b0,
     0x03ce,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xce\x86",
     "\xc3\xa7",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xaf",
     "\xc3\xae",
     "\xce\x88",
     "\xc3\x84",
     "\xce\x89",
     "\xce\x8a",
     "\xef\xbf\xbd",
     "\xce\x8c",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xce\x8e",
     "\xc3\xbb",
     "\xc3\xb9",
     "\xce\x8f",
     "\xc3\x96",
     "\xc3\x9c",
     "\xce\xac",
     "\xc2\xa3",
     "\xce\xad",
     "\xce\xae",
     "\xce\xaf",
     "\xcf\x8a",
     "\xce\x90",
     "\xcf\x8c",
     "\xcf\x8d",
     "\xce\x91",
     "\xce\x92",
     "\xce\x93",
     "\xce\x94",
     "\xce\x95",
     "\xce\x96",
     "\xce\x97",
     "\xc2\xbd",
     "\xce\x98",
     "\xce\x99",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xce\x9a",
     "\xce\x9b",
     "\xce\x9d",
     "\xce\x9c",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xce\x9e",
     "\xce\x9f",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xce\xa0",
     "\xce\xa1",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xce\xa3",
     "\xce\xa4",
     "\xce\xa5",
     "\xce\xa6",
     "\xce\xa7",
     "\xce\xa8",
     "\xce\xa9",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\xb3",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xce\xb4",
     "\xce\xb5",
     "\xe2\x96\x80",
     "\xce\xb6",
     "\xce\xb7",
     "\xce\xb8",
     "\xce\xb9",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xce\xbd",
     "\xce\xbe",
     "\xce\xbf",
     "\xcf\x80",
     "\xcf\x81",
     "\xcf\x83",
     "\xcf\x82",
     "\xcf\x84",
     "\xc2\xb4",
     "\xc2\xad",
     "\xc2\xb1",
     "\xcf\x85",
     "\xcf\x86",
     "\xcf\x87",
     "\xc2\xa7",
     "\xcf\x88",
     "\xcb\x9b",
     "\xc2\xb0",
     "\xc2\xa8",
     "\xcf\x89",
     "\xcf\x8b",
     "\xce\xb0",
     "\xcf\x8e",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a3 => "\x9c",
     0x000000a7 => "\xf5",
     0x000000a8 => "\xf9",
     0x000000ab => "\xae",
     0x000000ad => "\xf0",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b4 => "\xef",
     0x000000bb => "\xaf",
     0x000000bd => "\xab",
     0x000000c4 => "\x8e",
     0x000000c7 => "\x80",
     0x000000d6 => "\x99",
     0x000000dc => "\x9a",
     0x000000e0 => "\x85",
     0x000000e2 => "\x83",
     0x000000e4 => "\x84",
     0x000000e7 => "\x87",
     0x000000e8 => "\x8a",
     0x000000e9 => "\x82",
     0x000000ea => "\x88",
     0x000000eb => "\x89",
     0x000000ee => "\x8c",
     0x000000ef => "\x8b",
     0x000000f4 => "\x93",
     0x000000f6 => "\x94",
     0x000000f9 => "\x97",
     0x000000fb => "\x96",
     0x000000fc => "\x81",
     0x000002db => "\xf7",
     0x00000386 => "\x86",
     0x00000388 => "\x8d",
     0x00000389 => "\x8f",
     0x0000038a => "\x90",
     0x0000038c => "\x92",
     0x0000038e => "\x95",
     0x0000038f => "\x98",
     0x00000390 => "\xa1",
     0x00000391 => "\xa4",
     0x00000392 => "\xa5",
     0x00000393 => "\xa6",
     0x00000394 => "\xa7",
     0x00000395 => "\xa8",
     0x00000396 => "\xa9",
     0x00000397 => "\xaa",
     0x00000398 => "\xac",
     0x00000399 => "\xad",
     0x0000039a => "\xb5",
     0x0000039b => "\xb6",
     0x0000039c => "\xb8",
     0x0000039d => "\xb7",
     0x0000039e => "\xbd",
     0x0000039f => "\xbe",
     0x000003a0 => "\xc6",
     0x000003a1 => "\xc7",
     0x000003a3 => "\xcf",
     0x000003a4 => "\xd0",
     0x000003a5 => "\xd1",
     0x000003a6 => "\xd2",
     0x000003a7 => "\xd3",
     0x000003a8 => "\xd4",
     0x000003a9 => "\xd5",
     0x000003ac => "\x9b",
     0x000003ad => "\x9d",
     0x000003ae => "\x9e",
     0x000003af => "\x9f",
     0x000003b0 => "\xfc",
     0x000003b1 => "\xd6",
     0x000003b2 => "\xd7",
     0x000003b3 => "\xd8",
     0x000003b4 => "\xdd",
     0x000003b5 => "\xde",
     0x000003b6 => "\xe0",
     0x000003b7 => "\xe1",
     0x000003b8 => "\xe2",
     0x000003b9 => "\xe3",
     0x000003ba => "\xe4",
     0x000003bb => "\xe5",
     0x000003bc => "\xe6",
     0x000003bd => "\xe7",
     0x000003be => "\xe8",
     0x000003bf => "\xe9",
     0x000003c0 => "\xea",
     0x000003c1 => "\xeb",
     0x000003c2 => "\xed",
     0x000003c3 => "\xec",
     0x000003c4 => "\xee",
     0x000003c5 => "\xf2",
     0x000003c6 => "\xf3",
     0x000003c7 => "\xf4",
     0x000003c8 => "\xf6",
     0x000003c9 => "\xfa",
     0x000003ca => "\xa0",
     0x000003cb => "\xfb",
     0x000003cc => "\xa2",
     0x000003cd => "\xa3",
     0x000003ce => "\xfd",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002554 => "\xc9",
     0x00002557 => "\xbb",
     0x0000255a => "\xc8",
     0x0000255d => "\xbc",
     0x00002560 => "\xcc",
     0x00002563 => "\xb9",
     0x00002566 => "\xcb",
     0x00002569 => "\xca",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM852.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM852;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00e4,
     0x016f,
     0x0107,
     0x00e7,
     0x0142,
     0x00eb,
     0x0150,
     0x0151,
     0x00ee,
     0x0179,
     0x00c4,
     0x0106,
     0x00c9,
     0x0139,
     0x013a,
     0x00f4,
     0x00f6,
     0x013d,
     0x013e,
     0x015a,
     0x015b,
     0x00d6,
     0x00dc,
     0x0164,
     0x0165,
     0x0141,
     0x00d7,
     0x010d,
     0x00e1,
     0x00ed,
     0x00f3,
     0x00fa,
     0x0104,
     0x0105,
     0x017d,
     0x017e,
     0x0118,
     0x0119,
     0x00ac,
     0x017a,
     0x010c,
     0x015f,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x00c1,
     0x00c2,
     0x011a,
     0x015e,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x017b,
     0x017c,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x0102,
     0x0103,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x00a4,
     0x0111,
     0x0110,
     0x010e,
     0x00cb,
     0x010f,
     0x0147,
     0x00cd,
     0x00ce,
     0x011b,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x0162,
     0x016e,
     0x2580,
     0x00d3,
     0x00df,
     0x00d4,
     0x0143,
     0x0144,
     0x0148,
     0x0160,
     0x0161,
     0x0154,
     0x00da,
     0x0155,
     0x0170,
     0x00fd,
     0x00dd,
     0x0163,
     0x00b4,
     0x00ad,
     0x02dd,
     0x02db,
     0x02c7,
     0x02d8,
     0x00a7,
     0x00f7,
     0x00b8,
     0x00b0,
     0x00a8,
     0x02d9,
     0x0171,
     0x0158,
     0x0159,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc5\xaf",
     "\xc4\x87",
     "\xc3\xa7",
     "\xc5\x82",
     "\xc3\xab",
     "\xc5\x90",
     "\xc5\x91",
     "\xc3\xae",
     "\xc5\xb9",
     "\xc3\x84",
     "\xc4\x86",
     "\xc3\x89",
     "\xc4\xb9",
     "\xc4\xba",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc4\xbd",
     "\xc4\xbe",
     "\xc5\x9a",
     "\xc5\x9b",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc5\xa4",
     "\xc5\xa5",
     "\xc5\x81",
     "\xc3\x97",
     "\xc4\x8d",
     "\xc3\xa1",
     "\xc3\xad",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc4\x84",
     "\xc4\x85",
     "\xc5\xbd",
     "\xc5\xbe",
     "\xc4\x98",
     "\xc4\x99",
     "\xc2\xac",
     "\xc5\xba",
     "\xc4\x8c",
     "\xc5\x9f",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xc3\x81",
     "\xc3\x82",
     "\xc4\x9a",
     "\xc5\x9e",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xc5\xbb",
     "\xc5\xbc",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xc4\x82",
     "\xc4\x83",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xc2\xa4",
     "\xc4\x91",
     "\xc4\x90",
     "\xc4\x8e",
     "\xc3\x8b",
     "\xc4\x8f",
     "\xc5\x87",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc4\x9b",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xc5\xa2",
     "\xc5\xae",
     "\xe2\x96\x80",
     "\xc3\x93",
     "\xc3\x9f",
     "\xc3\x94",
     "\xc5\x83",
     "\xc5\x84",
     "\xc5\x88",
     "\xc5\xa0",
     "\xc5\xa1",
     "\xc5\x94",
     "\xc3\x9a",
     "\xc5\x95",
     "\xc5\xb0",
     "\xc3\xbd",
     "\xc3\x9d",
     "\xc5\xa3",
     "\xc2\xb4",
     "\xc2\xad",
     "\xcb\x9d",
     "\xcb\x9b",
     "\xcb\x87",
     "\xcb\x98",
     "\xc2\xa7",
     "\xc3\xb7",
     "\xc2\xb8",
     "\xc2\xb0",
     "\xc2\xa8",
     "\xcb\x99",
     "\xc5\xb1",
     "\xc5\x98",
     "\xc5\x99",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a4 => "\xcf",
     0x000000a7 => "\xf5",
     0x000000a8 => "\xf9",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000ad => "\xf0",
     0x000000b0 => "\xf8",
     0x000000b4 => "\xef",
     0x000000b8 => "\xf7",
     0x000000bb => "\xaf",
     0x000000c1 => "\xb5",
     0x000000c2 => "\xb6",
     0x000000c4 => "\x8e",
     0x000000c7 => "\x80",
     0x000000c9 => "\x90",
     0x000000cb => "\xd3",
     0x000000cd => "\xd6",
     0x000000ce => "\xd7",
     0x000000d3 => "\xe0",
     0x000000d4 => "\xe2",
     0x000000d6 => "\x99",
     0x000000d7 => "\x9e",
     0x000000da => "\xe9",
     0x000000dc => "\x9a",
     0x000000dd => "\xed",
     0x000000df => "\xe1",
     0x000000e1 => "\xa0",
     0x000000e2 => "\x83",
     0x000000e4 => "\x84",
     0x000000e7 => "\x87",
     0x000000e9 => "\x82",
     0x000000eb => "\x89",
     0x000000ed => "\xa1",
     0x000000ee => "\x8c",
     0x000000f3 => "\xa2",
     0x000000f4 => "\x93",
     0x000000f6 => "\x94",
     0x000000f7 => "\xf6",
     0x000000fa => "\xa3",
     0x000000fc => "\x81",
     0x000000fd => "\xec",
     0x00000102 => "\xc6",
     0x00000103 => "\xc7",
     0x00000104 => "\xa4",
     0x00000105 => "\xa5",
     0x00000106 => "\x8f",
     0x00000107 => "\x86",
     0x0000010c => "\xac",
     0x0000010d => "\x9f",
     0x0000010e => "\xd2",
     0x0000010f => "\xd4",
     0x00000110 => "\xd1",
     0x00000111 => "\xd0",
     0x00000118 => "\xa8",
     0x00000119 => "\xa9",
     0x0000011a => "\xb7",
     0x0000011b => "\xd8",
     0x00000139 => "\x91",
     0x0000013a => "\x92",
     0x0000013d => "\x95",
     0x0000013e => "\x96",
     0x00000141 => "\x9d",
     0x00000142 => "\x88",
     0x00000143 => "\xe3",
     0x00000144 => "\xe4",
     0x00000147 => "\xd5",
     0x00000148 => "\xe5",
     0x00000150 => "\x8a",
     0x00000151 => "\x8b",
     0x00000154 => "\xe8",
     0x00000155 => "\xea",
     0x00000158 => "\xfc",
     0x00000159 => "\xfd",
     0x0000015a => "\x97",
     0x0000015b => "\x98",
     0x0000015e => "\xb8",
     0x0000015f => "\xad",
     0x00000160 => "\xe6",
     0x00000161 => "\xe7",
     0x00000162 => "\xdd",
     0x00000163 => "\xee",
     0x00000164 => "\x9b",
     0x00000165 => "\x9c",
     0x0000016e => "\xde",
     0x0000016f => "\x85",
     0x00000170 => "\xeb",
     0x00000171 => "\xfb",
     0x00000179 => "\x8d",
     0x0000017a => "\xab",
     0x0000017b => "\xbd",
     0x0000017c => "\xbe",
     0x0000017d => "\xa6",
     0x0000017e => "\xa7",
     0x000002c7 => "\xf3",
     0x000002d8 => "\xf4",
     0x000002d9 => "\xfa",
     0x000002db => "\xf2",
     0x000002dd => "\xf1",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002554 => "\xc9",
     0x00002557 => "\xbb",
     0x0000255a => "\xc8",
     0x0000255d => "\xbc",
     0x00002560 => "\xcc",
     0x00002563 => "\xb9",
     0x00002566 => "\xcb",
     0x00002569 => "\xca",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM855.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM855;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0452,
     0x0402,
     0x0453,
     0x0403,
     0x0451,
     0x0401,
     0x0454,
     0x0404,
     0x0455,
     0x0405,
     0x0456,
     0x0406,
     0x0457,
     0x0407,
     0x0458,
     0x0408,
     0x0459,
     0x0409,
     0x045a,
     0x040a,
     0x045b,
     0x040b,
     0x045c,
     0x040c,
     0x045e,
     0x040e,
     0x045f,
     0x040f,
     0x044e,
     0x042e,
     0x044a,
     0x042a,
     0x0430,
     0x0410,
     0x0431,
     0x0411,
     0x0446,
     0x0426,
     0x0434,
     0x0414,
     0x0435,
     0x0415,
     0x0444,
     0x0424,
     0x0433,
     0x0413,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x0445,
     0x0425,
     0x0438,
     0x0418,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x0439,
     0x0419,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x043a,
     0x041a,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x00a4,
     0x043b,
     0x041b,
     0x043c,
     0x041c,
     0x043d,
     0x041d,
     0x043e,
     0x041e,
     0x043f,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x041f,
     0x044f,
     0x2580,
     0x042f,
     0x0440,
     0x0420,
     0x0441,
     0x0421,
     0x0442,
     0x0422,
     0x0443,
     0x0423,
     0x0436,
     0x0416,
     0x0432,
     0x0412,
     0x044c,
     0x042c,
     0x2116,
     0x00ad,
     0x044b,
     0x042b,
     0x0437,
     0x0417,
     0x0448,
     0x0428,
     0x044d,
     0x042d,
     0x0449,
     0x0429,
     0x0447,
     0x0427,
     0x00a7,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xd1\x92",
     "\xd0\x82",
     "\xd1\x93",
     "\xd0\x83",
     "\xd1\x91",
     "\xd0\x81",
     "\xd1\x94",
     "\xd0\x84",
     "\xd1\x95",
     "\xd0\x85",
     "\xd1\x96",
     "\xd0\x86",
     "\xd1\x97",
     "\xd0\x87",
     "\xd1\x98",
     "\xd0\x88",
     "\xd1\x99",
     "\xd0\x89",
     "\xd1\x9a",
     "\xd0\x8a",
     "\xd1\x9b",
     "\xd0\x8b",
     "\xd1\x9c",
     "\xd0\x8c",
     "\xd1\x9e",
     "\xd0\x8e",
     "\xd1\x9f",
     "\xd0\x8f",
     "\xd1\x8e",
     "\xd0\xae",
     "\xd1\x8a",
     "\xd0\xaa",
     "\xd0\xb0",
     "\xd0\x90",
     "\xd0\xb1",
     "\xd0\x91",
     "\xd1\x86",
     "\xd0\xa6",
     "\xd0\xb4",
     "\xd0\x94",
     "\xd0\xb5",
     "\xd0\x95",
     "\xd1\x84",
     "\xd0\xa4",
     "\xd0\xb3",
     "\xd0\x93",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xd1\x85",
     "\xd0\xa5",
     "\xd0\xb8",
     "\xd0\x98",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xd0\xb9",
     "\xd0\x99",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xd0\xba",
     "\xd0\x9a",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xc2\xa4",
     "\xd0\xbb",
     "\xd0\x9b",
     "\xd0\xbc",
     "\xd0\x9c",
     "\xd0\xbd",
     "\xd0\x9d",
     "\xd0\xbe",
     "\xd0\x9e",
     "\xd0\xbf",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xd0\x9f",
     "\xd1\x8f",
     "\xe2\x96\x80",
     "\xd0\xaf",
     "\xd1\x80",
     "\xd0\xa0",
     "\xd1\x81",
     "\xd0\xa1",
     "\xd1\x82",
     "\xd0\xa2",
     "\xd1\x83",
     "\xd0\xa3",
     "\xd0\xb6",
     "\xd0\x96",
     "\xd0\xb2",
     "\xd0\x92",
     "\xd1\x8c",
     "\xd0\xac",
     "\xe2\x84\x96",
     "\xc2\xad",
     "\xd1\x8b",
     "\xd0\xab",
     "\xd0\xb7",
     "\xd0\x97",
     "\xd1\x88",
     "\xd0\xa8",
     "\xd1\x8d",
     "\xd0\xad",
     "\xd1\x89",
     "\xd0\xa9",
     "\xd1\x87",
     "\xd0\xa7",
     "\xc2\xa7",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a4 => "\xcf",
     0x000000a7 => "\xfd",
     0x000000ab => "\xae",
     0x000000ad => "\xf0",
     0x000000bb => "\xaf",
     0x00000401 => "\x85",
     0x00000402 => "\x81",
     0x00000403 => "\x83",
     0x00000404 => "\x87",
     0x00000405 => "\x89",
     0x00000406 => "\x8b",
     0x00000407 => "\x8d",
     0x00000408 => "\x8f",
     0x00000409 => "\x91",
     0x0000040a => "\x93",
     0x0000040b => "\x95",
     0x0000040c => "\x97",
     0x0000040e => "\x99",
     0x0000040f => "\x9b",
     0x00000410 => "\xa1",
     0x00000411 => "\xa3",
     0x00000412 => "\xec",
     0x00000413 => "\xad",
     0x00000414 => "\xa7",
     0x00000415 => "\xa9",
     0x00000416 => "\xea",
     0x00000417 => "\xf4",
     0x00000418 => "\xb8",
     0x00000419 => "\xbe",
     0x0000041a => "\xc7",
     0x0000041b => "\xd1",
     0x0000041c => "\xd3",
     0x0000041d => "\xd5",
     0x0000041e => "\xd7",
     0x0000041f => "\xdd",
     0x00000420 => "\xe2",
     0x00000421 => "\xe4",
     0x00000422 => "\xe6",
     0x00000423 => "\xe8",
     0x00000424 => "\xab",
     0x00000425 => "\xb6",
     0x00000426 => "\xa5",
     0x00000427 => "\xfc",
     0x00000428 => "\xf6",
     0x00000429 => "\xfa",
     0x0000042a => "\x9f",
     0x0000042b => "\xf2",
     0x0000042c => "\xee",
     0x0000042d => "\xf8",
     0x0000042e => "\x9d",
     0x0000042f => "\xe0",
     0x00000430 => "\xa0",
     0x00000431 => "\xa2",
     0x00000432 => "\xeb",
     0x00000433 => "\xac",
     0x00000434 => "\xa6",
     0x00000435 => "\xa8",
     0x00000436 => "\xe9",
     0x00000437 => "\xf3",
     0x00000438 => "\xb7",
     0x00000439 => "\xbd",
     0x0000043a => "\xc6",
     0x0000043b => "\xd0",
     0x0000043c => "\xd2",
     0x0000043d => "\xd4",
     0x0000043e => "\xd6",
     0x0000043f => "\xd8",
     0x00000440 => "\xe1",
     0x00000441 => "\xe3",
     0x00000442 => "\xe5",
     0x00000443 => "\xe7",
     0x00000444 => "\xaa",
     0x00000445 => "\xb5",
     0x00000446 => "\xa4",
     0x00000447 => "\xfb",
     0x00000448 => "\xf5",
     0x00000449 => "\xf9",
     0x0000044a => "\x9e",
     0x0000044b => "\xf1",
     0x0000044c => "\xed",
     0x0000044d => "\xf7",
     0x0000044e => "\x9c",
     0x0000044f => "\xde",
     0x00000451 => "\x84",
     0x00000452 => "\x80",
     0x00000453 => "\x82",
     0x00000454 => "\x86",
     0x00000455 => "\x88",
     0x00000456 => "\x8a",
     0x00000457 => "\x8c",
     0x00000458 => "\x8e",
     0x00000459 => "\x90",
     0x0000045a => "\x92",
     0x0000045b => "\x94",
     0x0000045c => "\x96",
     0x0000045e => "\x98",
     0x0000045f => "\x9a",
     0x00002116 => "\xef",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002554 => "\xc9",
     0x00002557 => "\xbb",
     0x0000255a => "\xc8",
     0x0000255d => "\xbc",
     0x00002560 => "\xcc",
     0x00002563 => "\xb9",
     0x00002566 => "\xcb",
     0x00002569 => "\xca",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM857.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM857;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e5,
     0x00e7,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ef,
     0x00ee,
     0x0131,
     0x00c4,
     0x00c5,
     0x00c9,
     0x00e6,
     0x00c6,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00fb,
     0x00f9,
     0x0130,
     0x00d6,
     0x00dc,
     0x00f8,
     0x00a3,
     0x00d8,
     0x015e,
     0x015f,
     0x00e1,
     0x00ed,
     0x00f3,
     0x00fa,
     0x00f1,
     0x00d1,
     0x011e,
     0x011f,
     0x00bf,
     0x00ae,
     0x00ac,
     0x00bd,
     0x00bc,
     0x00a1,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x00c1,
     0x00c2,
     0x00c0,
     0x00a9,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x00a2,
     0x00a5,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x00e3,
     0x00c3,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x00a4,
     0x00ba,
     0x00aa,
     0x00ca,
     0x00cb,
     0x00c8,
     0xfffd,
     0x00cd,
     0x00ce,
     0x00cf,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x00a6,
     0x00cc,
     0x2580,
     0x00d3,
     0x00df,
     0x00d4,
     0x00d2,
     0x00f5,
     0x00d5,
     0x00b5,
     0xfffd,
     0x00d7,
     0x00da,
     0x00db,
     0x00d9,
     0x00ec,
     0x00ff,
     0x00af,
     0x00b4,
     0x00ad,
     0x00b1,
     0xfffd,
     0x00be,
     0x00b6,
     0x00a7,
     0x00f7,
     0x00b8,
     0x00b0,
     0x00a8,
     0x00b7,
     0x00b9,
     0x00b3,
     0x00b2,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xaf",
     "\xc3\xae",
     "\xc4\xb1",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x89",
     "\xc3\xa6",
     "\xc3\x86",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xbb",
     "\xc3\xb9",
     "\xc4\xb0",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xb8",
     "\xc2\xa3",
     "\xc3\x98",
     "\xc5\x9e",
     "\xc5\x9f",
     "\xc3\xa1",
     "\xc3\xad",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc3\xb1",
     "\xc3\x91",
     "\xc4\x9e",
     "\xc4\x9f",
     "\xc2\xbf",
     "\xc2\xae",
     "\xc2\xac",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xc2\xa1",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x80",
     "\xc2\xa9",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xc2\xa2",
     "\xc2\xa5",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xc3\xa3",
     "\xc3\x83",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xc2\xa4",
     "\xc2\xba",
     "\xc2\xaa",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xef\xbf\xbd",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xc2\xa6",
     "\xc3\x8c",
     "\xe2\x96\x80",
     "\xc3\x93",
     "\xc3\x9f",
     "\xc3\x94",
     "\xc3\x92",
     "\xc3\xb5",
     "\xc3\x95",
     "\xc2\xb5",
     "\xef\xbf\xbd",
     "\xc3\x97",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x99",
     "\xc3\xac",
     "\xc3\xbf",
     "\xc2\xaf",
     "\xc2\xb4",
     "\xc2\xad",
     "\xc2\xb1",
     "\xef\xbf\xbd",
     "\xc2\xbe",
     "\xc2\xb6",
     "\xc2\xa7",
     "\xc3\xb7",
     "\xc2\xb8",
     "\xc2\xb0",
     "\xc2\xa8",
     "\xc2\xb7",
     "\xc2\xb9",
     "\xc2\xb3",
     "\xc2\xb2",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a1 => "\xad",
     0x000000a2 => "\xbd",
     0x000000a3 => "\x9c",
     0x000000a4 => "\xcf",
     0x000000a5 => "\xbe",
     0x000000a6 => "\xdd",
     0x000000a7 => "\xf5",
     0x000000a8 => "\xf9",
     0x000000a9 => "\xb8",
     0x000000aa => "\xd1",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000ad => "\xf0",
     0x000000ae => "\xa9",
     0x000000af => "\xee",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b2 => "\xfd",
     0x000000b3 => "\xfc",
     0x000000b4 => "\xef",
     0x000000b5 => "\xe6",
     0x000000b6 => "\xf4",
     0x000000b7 => "\xfa",
     0x000000b8 => "\xf7",
     0x000000b9 => "\xfb",
     0x000000ba => "\xd0",
     0x000000bb => "\xaf",
     0x000000bc => "\xac",
     0x000000bd => "\xab",
     0x000000be => "\xf3",
     0x000000bf => "\xa8",
     0x000000c0 => "\xb7",
     0x000000c1 => "\xb5",
     0x000000c2 => "\xb6",
     0x000000c3 => "\xc7",
     0x000000c4 => "\x8e",
     0x000000c5 => "\x8f",
     0x000000c6 => "\x92",
     0x000000c7 => "\x80",
     0x000000c8 => "\xd4",
     0x000000c9 => "\x90",
     0x000000ca => "\xd2",
     0x000000cb => "\xd3",
     0x000000cc => "\xde",
     0x000000cd => "\xd6",
     0x000000ce => "\xd7",
     0x000000cf => "\xd8",
     0x000000d1 => "\xa5",
     0x000000d2 => "\xe3",
     0x000000d3 => "\xe0",
     0x000000d4 => "\xe2",
     0x000000d5 => "\xe5",
     0x000000d6 => "\x99",
     0x000000d7 => "\xe8",
     0x000000d8 => "\x9d",
     0x000000d9 => "\xeb",
     0x000000da => "\xe9",
     0x000000db => "\xea",
     0x000000dc => "\x9a",
     0x000000df => "\xe1",
     0x000000e0 => "\x85",
     0x000000e1 => "\xa0",
     0x000000e2 => "\x83",
     0x000000e3 => "\xc6",
     0x000000e4 => "\x84",
     0x000000e5 => "\x86",
     0x000000e6 => "\x91",
     0x000000e7 => "\x87",
     0x000000e8 => "\x8a",
     0x000000e9 => "\x82",
     0x000000ea => "\x88",
     0x000000eb => "\x89",
     0x000000ec => "\xec",
     0x000000ed => "\xa1",
     0x000000ee => "\x8c",
     0x000000ef => "\x8b",
     0x000000f1 => "\xa4",
     0x000000f2 => "\x95",
     0x000000f3 => "\xa2",
     0x000000f4 => "\x93",
     0x000000f5 => "\xe4",
     0x000000f6 => "\x94",
     0x000000f7 => "\xf6",
     0x000000f8 => "\x9b",
     0x000000f9 => "\x97",
     0x000000fa => "\xa3",
     0x000000fb => "\x96",
     0x000000fc => "\x81",
     0x000000ff => "\xed",
     0x0000011e => "\xa6",
     0x0000011f => "\xa7",
     0x00000130 => "\x98",
     0x00000131 => "\x8d",
     0x0000015e => "\x9e",
     0x0000015f => "\x9f",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002554 => "\xc9",
     0x00002557 => "\xbb",
     0x0000255a => "\xc8",
     0x0000255d => "\xbc",
     0x00002560 => "\xcc",
     0x00002563 => "\xb9",
     0x00002566 => "\xcb",
     0x00002569 => "\xca",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM860.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM860;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00e3,
     0x00e0,
     0x00c1,
     0x00e7,
     0x00ea,
     0x00ca,
     0x00e8,
     0x00cd,
     0x00d4,
     0x00ec,
     0x00c3,
     0x00c2,
     0x00c9,
     0x00c0,
     0x00c8,
     0x00f4,
     0x00f5,
     0x00f2,
     0x00da,
     0x00f9,
     0x00cc,
     0x00d5,
     0x00dc,
     0x00a2,
     0x00a3,
     0x00d9,
     0x20a7,
     0x00d3,
     0x00e1,
     0x00ed,
     0x00f3,
     0x00fa,
     0x00f1,
     0x00d1,
     0x00aa,
     0x00ba,
     0x00bf,
     0x00d2,
     0x00ac,
     0x00bd,
     0x00bc,
     0x00a1,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x2561,
     0x2562,
     0x2556,
     0x2555,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x255c,
     0x255b,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x255e,
     0x255f,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x2567,
     0x2568,
     0x2564,
     0x2565,
     0x2559,
     0x2558,
     0x2552,
     0x2553,
     0x256b,
     0x256a,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x258c,
     0x2590,
     0x2580,
     0x03b1,
     0x00df,
     0x0393,
     0x03c0,
     0x03a3,
     0x03c3,
     0x00b5,
     0x03c4,
     0x03a6,
     0x0398,
     0x03a9,
     0x03b4,
     0x221e,
     0x03c6,
     0x03b5,
     0x2229,
     0x2261,
     0x00b1,
     0x2265,
     0x2264,
     0x2320,
     0x2321,
     0x00f7,
     0x2248,
     0x00b0,
     0x2219,
     0x00b7,
     0x221a,
     0x207f,
     0x00b2,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa0",
     "\xc3\x81",
     "\xc3\xa7",
     "\xc3\xaa",
     "\xc3\x8a",
     "\xc3\xa8",
     "\xc3\x8d",
     "\xc3\x94",
     "\xc3\xac",
     "\xc3\x83",
     "\xc3\x82",
     "\xc3\x89",
     "\xc3\x80",
     "\xc3\x88",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb2",
     "\xc3\x9a",
     "\xc3\xb9",
     "\xc3\x8c",
     "\xc3\x95",
     "\xc3\x9c",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc3\x99",
     "\xe2\x82\xa7",
     "\xc3\x93",
     "\xc3\xa1",
     "\xc3\xad",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc3\xb1",
     "\xc3\x91",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc2\xbf",
     "\xc3\x92",
     "\xc2\xac",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xc2\xa1",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xe2\x95\xa1",
     "\xe2\x95\xa2",
     "\xe2\x95\x96",
     "\xe2\x95\x95",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xe2\x95\x9c",
     "\xe2\x95\x9b",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xe2\x95\x9e",
     "\xe2\x95\x9f",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xe2\x95\xa7",
     "\xe2\x95\xa8",
     "\xe2\x95\xa4",
     "\xe2\x95\xa5",
     "\xe2\x95\x99",
     "\xe2\x95\x98",
     "\xe2\x95\x92",
     "\xe2\x95\x93",
     "\xe2\x95\xab",
     "\xe2\x95\xaa",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xe2\x96\x8c",
     "\xe2\x96\x90",
     "\xe2\x96\x80",
     "\xce\xb1",
     "\xc3\x9f",
     "\xce\x93",
     "\xcf\x80",
     "\xce\xa3",
     "\xcf\x83",
     "\xc2\xb5",
     "\xcf\x84",
     "\xce\xa6",
     "\xce\x98",
     "\xce\xa9",
     "\xce\xb4",
     "\xe2\x88\x9e",
     "\xcf\x86",
     "\xce\xb5",
     "\xe2\x88\xa9",
     "\xe2\x89\xa1",
     "\xc2\xb1",
     "\xe2\x89\xa5",
     "\xe2\x89\xa4",
     "\xe2\x8c\xa0",
     "\xe2\x8c\xa1",
     "\xc3\xb7",
     "\xe2\x89\x88",
     "\xc2\xb0",
     "\xe2\x88\x99",
     "\xc2\xb7",
     "\xe2\x88\x9a",
     "\xe2\x81\xbf",
     "\xc2\xb2",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a1 => "\xad",
     0x000000a2 => "\x9b",
     0x000000a3 => "\x9c",
     0x000000aa => "\xa6",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b2 => "\xfd",
     0x000000b5 => "\xe6",
     0x000000b7 => "\xfa",
     0x000000ba => "\xa7",
     0x000000bb => "\xaf",
     0x000000bc => "\xac",
     0x000000bd => "\xab",
     0x000000bf => "\xa8",
     0x000000c0 => "\x91",
     0x000000c1 => "\x86",
     0x000000c2 => "\x8f",
     0x000000c3 => "\x8e",
     0x000000c7 => "\x80",
     0x000000c8 => "\x92",
     0x000000c9 => "\x90",
     0x000000ca => "\x89",
     0x000000cc => "\x98",
     0x000000cd => "\x8b",
     0x000000d1 => "\xa5",
     0x000000d2 => "\xa9",
     0x000000d3 => "\x9f",
     0x000000d4 => "\x8c",
     0x000000d5 => "\x99",
     0x000000d9 => "\x9d",
     0x000000da => "\x96",
     0x000000dc => "\x9a",
     0x000000df => "\xe1",
     0x000000e0 => "\x85",
     0x000000e1 => "\xa0",
     0x000000e2 => "\x83",
     0x000000e3 => "\x84",
     0x000000e7 => "\x87",
     0x000000e8 => "\x8a",
     0x000000e9 => "\x82",
     0x000000ea => "\x88",
     0x000000ec => "\x8d",
     0x000000ed => "\xa1",
     0x000000f1 => "\xa4",
     0x000000f2 => "\x95",
     0x000000f3 => "\xa2",
     0x000000f4 => "\x93",
     0x000000f5 => "\x94",
     0x000000f7 => "\xf6",
     0x000000f9 => "\x97",
     0x000000fa => "\xa3",
     0x000000fc => "\x81",
     0x00000393 => "\xe2",
     0x00000398 => "\xe9",
     0x000003a3 => "\xe4",
     0x000003a6 => "\xe8",
     0x000003a9 => "\xea",
     0x000003b1 => "\xe0",
     0x000003b4 => "\xeb",
     0x000003b5 => "\xee",
     0x000003c0 => "\xe3",
     0x000003c3 => "\xe5",
     0x000003c4 => "\xe7",
     0x000003c6 => "\xed",
     0x0000207f => "\xfc",
     0x000020a7 => "\x9e",
     0x00002219 => "\xf9",
     0x0000221a => "\xfb",
     0x0000221e => "\xec",
     0x00002229 => "\xef",
     0x00002248 => "\xf7",
     0x00002261 => "\xf0",
     0x00002264 => "\xf3",
     0x00002265 => "\xf2",
     0x00002320 => "\xf4",
     0x00002321 => "\xf5",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002552 => "\xd5",
     0x00002553 => "\xd6",
     0x00002554 => "\xc9",
     0x00002555 => "\xb8",
     0x00002556 => "\xb7",
     0x00002557 => "\xbb",
     0x00002558 => "\xd4",
     0x00002559 => "\xd3",
     0x0000255a => "\xc8",
     0x0000255b => "\xbe",
     0x0000255c => "\xbd",
     0x0000255d => "\xbc",
     0x0000255e => "\xc6",
     0x0000255f => "\xc7",
     0x00002560 => "\xcc",
     0x00002561 => "\xb5",
     0x00002562 => "\xb6",
     0x00002563 => "\xb9",
     0x00002564 => "\xd1",
     0x00002565 => "\xd2",
     0x00002566 => "\xcb",
     0x00002567 => "\xcf",
     0x00002568 => "\xd0",
     0x00002569 => "\xca",
     0x0000256a => "\xd8",
     0x0000256b => "\xd7",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x0000258c => "\xdd",
     0x00002590 => "\xde",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM861.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM861;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e5,
     0x00e7,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00d0,
     0x00f0,
     0x00de,
     0x00c4,
     0x00c5,
     0x00c9,
     0x00e6,
     0x00c6,
     0x00f4,
     0x00f6,
     0x00fe,
     0x00fb,
     0x00dd,
     0x00fd,
     0x00d6,
     0x00dc,
     0x00f8,
     0x00a3,
     0x00d8,
     0x20a7,
     0x0192,
     0x00e1,
     0x00ed,
     0x00f3,
     0x00fa,
     0x00c1,
     0x00cd,
     0x00d3,
     0x00da,
     0x00bf,
     0x2310,
     0x00ac,
     0x00bd,
     0x00bc,
     0x00a1,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x2561,
     0x2562,
     0x2556,
     0x2555,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x255c,
     0x255b,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x255e,
     0x255f,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x2567,
     0x2568,
     0x2564,
     0x2565,
     0x2559,
     0x2558,
     0x2552,
     0x2553,
     0x256b,
     0x256a,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x258c,
     0x2590,
     0x2580,
     0x03b1,
     0x00df,
     0x0393,
     0x03c0,
     0x03a3,
     0x03c3,
     0x00b5,
     0x03c4,
     0x03a6,
     0x0398,
     0x03a9,
     0x03b4,
     0x221e,
     0x03c6,
     0x03b5,
     0x2229,
     0x2261,
     0x00b1,
     0x2265,
     0x2264,
     0x2320,
     0x2321,
     0x00f7,
     0x2248,
     0x00b0,
     0x2219,
     0x00b7,
     0x221a,
     0x207f,
     0x00b2,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\x90",
     "\xc3\xb0",
     "\xc3\x9e",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x89",
     "\xc3\xa6",
     "\xc3\x86",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xbe",
     "\xc3\xbb",
     "\xc3\x9d",
     "\xc3\xbd",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xb8",
     "\xc2\xa3",
     "\xc3\x98",
     "\xe2\x82\xa7",
     "\xc6\x92",
     "\xc3\xa1",
     "\xc3\xad",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc3\x81",
     "\xc3\x8d",
     "\xc3\x93",
     "\xc3\x9a",
     "\xc2\xbf",
     "\xe2\x8c\x90",
     "\xc2\xac",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xc2\xa1",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xe2\x95\xa1",
     "\xe2\x95\xa2",
     "\xe2\x95\x96",
     "\xe2\x95\x95",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xe2\x95\x9c",
     "\xe2\x95\x9b",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xe2\x95\x9e",
     "\xe2\x95\x9f",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xe2\x95\xa7",
     "\xe2\x95\xa8",
     "\xe2\x95\xa4",
     "\xe2\x95\xa5",
     "\xe2\x95\x99",
     "\xe2\x95\x98",
     "\xe2\x95\x92",
     "\xe2\x95\x93",
     "\xe2\x95\xab",
     "\xe2\x95\xaa",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xe2\x96\x8c",
     "\xe2\x96\x90",
     "\xe2\x96\x80",
     "\xce\xb1",
     "\xc3\x9f",
     "\xce\x93",
     "\xcf\x80",
     "\xce\xa3",
     "\xcf\x83",
     "\xc2\xb5",
     "\xcf\x84",
     "\xce\xa6",
     "\xce\x98",
     "\xce\xa9",
     "\xce\xb4",
     "\xe2\x88\x9e",
     "\xcf\x86",
     "\xce\xb5",
     "\xe2\x88\xa9",
     "\xe2\x89\xa1",
     "\xc2\xb1",
     "\xe2\x89\xa5",
     "\xe2\x89\xa4",
     "\xe2\x8c\xa0",
     "\xe2\x8c\xa1",
     "\xc3\xb7",
     "\xe2\x89\x88",
     "\xc2\xb0",
     "\xe2\x88\x99",
     "\xc2\xb7",
     "\xe2\x88\x9a",
     "\xe2\x81\xbf",
     "\xc2\xb2",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a1 => "\xad",
     0x000000a3 => "\x9c",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b2 => "\xfd",
     0x000000b5 => "\xe6",
     0x000000b7 => "\xfa",
     0x000000bb => "\xaf",
     0x000000bc => "\xac",
     0x000000bd => "\xab",
     0x000000bf => "\xa8",
     0x000000c1 => "\xa4",
     0x000000c4 => "\x8e",
     0x000000c5 => "\x8f",
     0x000000c6 => "\x92",
     0x000000c7 => "\x80",
     0x000000c9 => "\x90",
     0x000000cd => "\xa5",
     0x000000d0 => "\x8b",
     0x000000d3 => "\xa6",
     0x000000d6 => "\x99",
     0x000000d8 => "\x9d",
     0x000000da => "\xa7",
     0x000000dc => "\x9a",
     0x000000dd => "\x97",
     0x000000de => "\x8d",
     0x000000df => "\xe1",
     0x000000e0 => "\x85",
     0x000000e1 => "\xa0",
     0x000000e2 => "\x83",
     0x000000e4 => "\x84",
     0x000000e5 => "\x86",
     0x000000e6 => "\x91",
     0x000000e7 => "\x87",
     0x000000e8 => "\x8a",
     0x000000e9 => "\x82",
     0x000000ea => "\x88",
     0x000000eb => "\x89",
     0x000000ed => "\xa1",
     0x000000f0 => "\x8c",
     0x000000f3 => "\xa2",
     0x000000f4 => "\x93",
     0x000000f6 => "\x94",
     0x000000f7 => "\xf6",
     0x000000f8 => "\x9b",
     0x000000fa => "\xa3",
     0x000000fb => "\x96",
     0x000000fc => "\x81",
     0x000000fd => "\x98",
     0x000000fe => "\x95",
     0x00000192 => "\x9f",
     0x00000393 => "\xe2",
     0x00000398 => "\xe9",
     0x000003a3 => "\xe4",
     0x000003a6 => "\xe8",
     0x000003a9 => "\xea",
     0x000003b1 => "\xe0",
     0x000003b4 => "\xeb",
     0x000003b5 => "\xee",
     0x000003c0 => "\xe3",
     0x000003c3 => "\xe5",
     0x000003c4 => "\xe7",
     0x000003c6 => "\xed",
     0x0000207f => "\xfc",
     0x000020a7 => "\x9e",
     0x00002219 => "\xf9",
     0x0000221a => "\xfb",
     0x0000221e => "\xec",
     0x00002229 => "\xef",
     0x00002248 => "\xf7",
     0x00002261 => "\xf0",
     0x00002264 => "\xf3",
     0x00002265 => "\xf2",
     0x00002310 => "\xa9",
     0x00002320 => "\xf4",
     0x00002321 => "\xf5",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002552 => "\xd5",
     0x00002553 => "\xd6",
     0x00002554 => "\xc9",
     0x00002555 => "\xb8",
     0x00002556 => "\xb7",
     0x00002557 => "\xbb",
     0x00002558 => "\xd4",
     0x00002559 => "\xd3",
     0x0000255a => "\xc8",
     0x0000255b => "\xbe",
     0x0000255c => "\xbd",
     0x0000255d => "\xbc",
     0x0000255e => "\xc6",
     0x0000255f => "\xc7",
     0x00002560 => "\xcc",
     0x00002561 => "\xb5",
     0x00002562 => "\xb6",
     0x00002563 => "\xb9",
     0x00002564 => "\xd1",
     0x00002565 => "\xd2",
     0x00002566 => "\xcb",
     0x00002567 => "\xcf",
     0x00002568 => "\xd0",
     0x00002569 => "\xca",
     0x0000256a => "\xd8",
     0x0000256b => "\xd7",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x0000258c => "\xdd",
     0x00002590 => "\xde",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM862.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM862;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x05d0,
     0x05d1,
     0x05d2,
     0x05d3,
     0x05d4,
     0x05d5,
     0x05d6,
     0x05d7,
     0x05d8,
     0x05d9,
     0x05da,
     0x05db,
     0x05dc,
     0x05dd,
     0x05de,
     0x05df,
     0x05e0,
     0x05e1,
     0x05e2,
     0x05e3,
     0x05e4,
     0x05e5,
     0x05e6,
     0x05e7,
     0x05e8,
     0x05e9,
     0x05ea,
     0x00a2,
     0x00a3,
     0x00a5,
     0x20a7,
     0x0192,
     0x00e1,
     0x00ed,
     0x00f3,
     0x00fa,
     0x00f1,
     0x00d1,
     0x00aa,
     0x00ba,
     0x00bf,
     0x2310,
     0x00ac,
     0x00bd,
     0x00bc,
     0x00a1,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x2561,
     0x2562,
     0x2556,
     0x2555,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x255c,
     0x255b,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x255e,
     0x255f,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x2567,
     0x2568,
     0x2564,
     0x2565,
     0x2559,
     0x2558,
     0x2552,
     0x2553,
     0x256b,
     0x256a,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x258c,
     0x2590,
     0x2580,
     0x03b1,
     0x00df,
     0x0393,
     0x03c0,
     0x03a3,
     0x03c3,
     0x00b5,
     0x03c4,
     0x03a6,
     0x0398,
     0x03a9,
     0x03b4,
     0x221e,
     0x03c6,
     0x03b5,
     0x2229,
     0x2261,
     0x00b1,
     0x2265,
     0x2264,
     0x2320,
     0x2321,
     0x00f7,
     0x2248,
     0x00b0,
     0x2219,
     0x00b7,
     0x221a,
     0x207f,
     0x00b2,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xd7\x90",
     "\xd7\x91",
     "\xd7\x92",
     "\xd7\x93",
     "\xd7\x94",
     "\xd7\x95",
     "\xd7\x96",
     "\xd7\x97",
     "\xd7\x98",
     "\xd7\x99",
     "\xd7\x9a",
     "\xd7\x9b",
     "\xd7\x9c",
     "\xd7\x9d",
     "\xd7\x9e",
     "\xd7\x9f",
     "\xd7\xa0",
     "\xd7\xa1",
     "\xd7\xa2",
     "\xd7\xa3",
     "\xd7\xa4",
     "\xd7\xa5",
     "\xd7\xa6",
     "\xd7\xa7",
     "\xd7\xa8",
     "\xd7\xa9",
     "\xd7\xaa",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xe2\x82\xa7",
     "\xc6\x92",
     "\xc3\xa1",
     "\xc3\xad",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc3\xb1",
     "\xc3\x91",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc2\xbf",
     "\xe2\x8c\x90",
     "\xc2\xac",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xc2\xa1",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xe2\x95\xa1",
     "\xe2\x95\xa2",
     "\xe2\x95\x96",
     "\xe2\x95\x95",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xe2\x95\x9c",
     "\xe2\x95\x9b",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xe2\x95\x9e",
     "\xe2\x95\x9f",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xe2\x95\xa7",
     "\xe2\x95\xa8",
     "\xe2\x95\xa4",
     "\xe2\x95\xa5",
     "\xe2\x95\x99",
     "\xe2\x95\x98",
     "\xe2\x95\x92",
     "\xe2\x95\x93",
     "\xe2\x95\xab",
     "\xe2\x95\xaa",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xe2\x96\x8c",
     "\xe2\x96\x90",
     "\xe2\x96\x80",
     "\xce\xb1",
     "\xc3\x9f",
     "\xce\x93",
     "\xcf\x80",
     "\xce\xa3",
     "\xcf\x83",
     "\xc2\xb5",
     "\xcf\x84",
     "\xce\xa6",
     "\xce\x98",
     "\xce\xa9",
     "\xce\xb4",
     "\xe2\x88\x9e",
     "\xcf\x86",
     "\xce\xb5",
     "\xe2\x88\xa9",
     "\xe2\x89\xa1",
     "\xc2\xb1",
     "\xe2\x89\xa5",
     "\xe2\x89\xa4",
     "\xe2\x8c\xa0",
     "\xe2\x8c\xa1",
     "\xc3\xb7",
     "\xe2\x89\x88",
     "\xc2\xb0",
     "\xe2\x88\x99",
     "\xc2\xb7",
     "\xe2\x88\x9a",
     "\xe2\x81\xbf",
     "\xc2\xb2",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a1 => "\xad",
     0x000000a2 => "\x9b",
     0x000000a3 => "\x9c",
     0x000000a5 => "\x9d",
     0x000000aa => "\xa6",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b2 => "\xfd",
     0x000000b5 => "\xe6",
     0x000000b7 => "\xfa",
     0x000000ba => "\xa7",
     0x000000bb => "\xaf",
     0x000000bc => "\xac",
     0x000000bd => "\xab",
     0x000000bf => "\xa8",
     0x000000d1 => "\xa5",
     0x000000df => "\xe1",
     0x000000e1 => "\xa0",
     0x000000ed => "\xa1",
     0x000000f1 => "\xa4",
     0x000000f3 => "\xa2",
     0x000000f7 => "\xf6",
     0x000000fa => "\xa3",
     0x00000192 => "\x9f",
     0x00000393 => "\xe2",
     0x00000398 => "\xe9",
     0x000003a3 => "\xe4",
     0x000003a6 => "\xe8",
     0x000003a9 => "\xea",
     0x000003b1 => "\xe0",
     0x000003b4 => "\xeb",
     0x000003b5 => "\xee",
     0x000003c0 => "\xe3",
     0x000003c3 => "\xe5",
     0x000003c4 => "\xe7",
     0x000003c6 => "\xed",
     0x000005d0 => "\x80",
     0x000005d1 => "\x81",
     0x000005d2 => "\x82",
     0x000005d3 => "\x83",
     0x000005d4 => "\x84",
     0x000005d5 => "\x85",
     0x000005d6 => "\x86",
     0x000005d7 => "\x87",
     0x000005d8 => "\x88",
     0x000005d9 => "\x89",
     0x000005da => "\x8a",
     0x000005db => "\x8b",
     0x000005dc => "\x8c",
     0x000005dd => "\x8d",
     0x000005de => "\x8e",
     0x000005df => "\x8f",
     0x000005e0 => "\x90",
     0x000005e1 => "\x91",
     0x000005e2 => "\x92",
     0x000005e3 => "\x93",
     0x000005e4 => "\x94",
     0x000005e5 => "\x95",
     0x000005e6 => "\x96",
     0x000005e7 => "\x97",
     0x000005e8 => "\x98",
     0x000005e9 => "\x99",
     0x000005ea => "\x9a",
     0x0000207f => "\xfc",
     0x000020a7 => "\x9e",
     0x00002219 => "\xf9",
     0x0000221a => "\xfb",
     0x0000221e => "\xec",
     0x00002229 => "\xef",
     0x00002248 => "\xf7",
     0x00002261 => "\xf0",
     0x00002264 => "\xf3",
     0x00002265 => "\xf2",
     0x00002310 => "\xa9",
     0x00002320 => "\xf4",
     0x00002321 => "\xf5",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002552 => "\xd5",
     0x00002553 => "\xd6",
     0x00002554 => "\xc9",
     0x00002555 => "\xb8",
     0x00002556 => "\xb7",
     0x00002557 => "\xbb",
     0x00002558 => "\xd4",
     0x00002559 => "\xd3",
     0x0000255a => "\xc8",
     0x0000255b => "\xbe",
     0x0000255c => "\xbd",
     0x0000255d => "\xbc",
     0x0000255e => "\xc6",
     0x0000255f => "\xc7",
     0x00002560 => "\xcc",
     0x00002561 => "\xb5",
     0x00002562 => "\xb6",
     0x00002563 => "\xb9",
     0x00002564 => "\xd1",
     0x00002565 => "\xd2",
     0x00002566 => "\xcb",
     0x00002567 => "\xcf",
     0x00002568 => "\xd0",
     0x00002569 => "\xca",
     0x0000256a => "\xd8",
     0x0000256b => "\xd7",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x0000258c => "\xdd",
     0x00002590 => "\xde",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM863.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM863;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00c2,
     0x00e0,
     0x00b6,
     0x00e7,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ef,
     0x00ee,
     0x2017,
     0x00c0,
     0x00a7,
     0x00c9,
     0x00c8,
     0x00ca,
     0x00f4,
     0x00cb,
     0x00cf,
     0x00fb,
     0x00f9,
     0x00a4,
     0x00d4,
     0x00dc,
     0x00a2,
     0x00a3,
     0x00d9,
     0x00db,
     0x0192,
     0x00a6,
     0x00b4,
     0x00f3,
     0x00fa,
     0x00a8,
     0x00b8,
     0x00b3,
     0x00af,
     0x00ce,
     0x2310,
     0x00ac,
     0x00bd,
     0x00bc,
     0x00be,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x2561,
     0x2562,
     0x2556,
     0x2555,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x255c,
     0x255b,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x255e,
     0x255f,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x2567,
     0x2568,
     0x2564,
     0x2565,
     0x2559,
     0x2558,
     0x2552,
     0x2553,
     0x256b,
     0x256a,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x258c,
     0x2590,
     0x2580,
     0x03b1,
     0x00df,
     0x0393,
     0x03c0,
     0x03a3,
     0x03c3,
     0x00b5,
     0x03c4,
     0x03a6,
     0x0398,
     0x03a9,
     0x03b4,
     0x221e,
     0x03c6,
     0x03b5,
     0x2229,
     0x2261,
     0x00b1,
     0x2265,
     0x2264,
     0x2320,
     0x2321,
     0x00f7,
     0x2248,
     0x00b0,
     0x2219,
     0x00b7,
     0x221a,
     0x207f,
     0x00b2,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\x82",
     "\xc3\xa0",
     "\xc2\xb6",
     "\xc3\xa7",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xaf",
     "\xc3\xae",
     "\xe2\x80\x97",
     "\xc3\x80",
     "\xc2\xa7",
     "\xc3\x89",
     "\xc3\x88",
     "\xc3\x8a",
     "\xc3\xb4",
     "\xc3\x8b",
     "\xc3\x8f",
     "\xc3\xbb",
     "\xc3\xb9",
     "\xc2\xa4",
     "\xc3\x94",
     "\xc3\x9c",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc3\x99",
     "\xc3\x9b",
     "\xc6\x92",
     "\xc2\xa6",
     "\xc2\xb4",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc2\xa8",
     "\xc2\xb8",
     "\xc2\xb3",
     "\xc2\xaf",
     "\xc3\x8e",
     "\xe2\x8c\x90",
     "\xc2\xac",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xc2\xbe",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xe2\x95\xa1",
     "\xe2\x95\xa2",
     "\xe2\x95\x96",
     "\xe2\x95\x95",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xe2\x95\x9c",
     "\xe2\x95\x9b",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xe2\x95\x9e",
     "\xe2\x95\x9f",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xe2\x95\xa7",
     "\xe2\x95\xa8",
     "\xe2\x95\xa4",
     "\xe2\x95\xa5",
     "\xe2\x95\x99",
     "\xe2\x95\x98",
     "\xe2\x95\x92",
     "\xe2\x95\x93",
     "\xe2\x95\xab",
     "\xe2\x95\xaa",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xe2\x96\x8c",
     "\xe2\x96\x90",
     "\xe2\x96\x80",
     "\xce\xb1",
     "\xc3\x9f",
     "\xce\x93",
     "\xcf\x80",
     "\xce\xa3",
     "\xcf\x83",
     "\xc2\xb5",
     "\xcf\x84",
     "\xce\xa6",
     "\xce\x98",
     "\xce\xa9",
     "\xce\xb4",
     "\xe2\x88\x9e",
     "\xcf\x86",
     "\xce\xb5",
     "\xe2\x88\xa9",
     "\xe2\x89\xa1",
     "\xc2\xb1",
     "\xe2\x89\xa5",
     "\xe2\x89\xa4",
     "\xe2\x8c\xa0",
     "\xe2\x8c\xa1",
     "\xc3\xb7",
     "\xe2\x89\x88",
     "\xc2\xb0",
     "\xe2\x88\x99",
     "\xc2\xb7",
     "\xe2\x88\x9a",
     "\xe2\x81\xbf",
     "\xc2\xb2",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a2 => "\x9b",
     0x000000a3 => "\x9c",
     0x000000a4 => "\x98",
     0x000000a6 => "\xa0",
     0x000000a7 => "\x8f",
     0x000000a8 => "\xa4",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000af => "\xa7",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b2 => "\xfd",
     0x000000b3 => "\xa6",
     0x000000b4 => "\xa1",
     0x000000b5 => "\xe6",
     0x000000b6 => "\x86",
     0x000000b7 => "\xfa",
     0x000000b8 => "\xa5",
     0x000000bb => "\xaf",
     0x000000bc => "\xac",
     0x000000bd => "\xab",
     0x000000be => "\xad",
     0x000000c0 => "\x8e",
     0x000000c2 => "\x84",
     0x000000c7 => "\x80",
     0x000000c8 => "\x91",
     0x000000c9 => "\x90",
     0x000000ca => "\x92",
     0x000000cb => "\x94",
     0x000000ce => "\xa8",
     0x000000cf => "\x95",
     0x000000d4 => "\x99",
     0x000000d9 => "\x9d",
     0x000000db => "\x9e",
     0x000000dc => "\x9a",
     0x000000df => "\xe1",
     0x000000e0 => "\x85",
     0x000000e2 => "\x83",
     0x000000e7 => "\x87",
     0x000000e8 => "\x8a",
     0x000000e9 => "\x82",
     0x000000ea => "\x88",
     0x000000eb => "\x89",
     0x000000ee => "\x8c",
     0x000000ef => "\x8b",
     0x000000f3 => "\xa2",
     0x000000f4 => "\x93",
     0x000000f7 => "\xf6",
     0x000000f9 => "\x97",
     0x000000fa => "\xa3",
     0x000000fb => "\x96",
     0x000000fc => "\x81",
     0x00000192 => "\x9f",
     0x00000393 => "\xe2",
     0x00000398 => "\xe9",
     0x000003a3 => "\xe4",
     0x000003a6 => "\xe8",
     0x000003a9 => "\xea",
     0x000003b1 => "\xe0",
     0x000003b4 => "\xeb",
     0x000003b5 => "\xee",
     0x000003c0 => "\xe3",
     0x000003c3 => "\xe5",
     0x000003c4 => "\xe7",
     0x000003c6 => "\xed",
     0x00002017 => "\x8d",
     0x0000207f => "\xfc",
     0x00002219 => "\xf9",
     0x0000221a => "\xfb",
     0x0000221e => "\xec",
     0x00002229 => "\xef",
     0x00002248 => "\xf7",
     0x00002261 => "\xf0",
     0x00002264 => "\xf3",
     0x00002265 => "\xf2",
     0x00002310 => "\xa9",
     0x00002320 => "\xf4",
     0x00002321 => "\xf5",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002552 => "\xd5",
     0x00002553 => "\xd6",
     0x00002554 => "\xc9",
     0x00002555 => "\xb8",
     0x00002556 => "\xb7",
     0x00002557 => "\xbb",
     0x00002558 => "\xd4",
     0x00002559 => "\xd3",
     0x0000255a => "\xc8",
     0x0000255b => "\xbe",
     0x0000255c => "\xbd",
     0x0000255d => "\xbc",
     0x0000255e => "\xc6",
     0x0000255f => "\xc7",
     0x00002560 => "\xcc",
     0x00002561 => "\xb5",
     0x00002562 => "\xb6",
     0x00002563 => "\xb9",
     0x00002564 => "\xd1",
     0x00002565 => "\xd2",
     0x00002566 => "\xcb",
     0x00002567 => "\xcf",
     0x00002568 => "\xd0",
     0x00002569 => "\xca",
     0x0000256a => "\xd8",
     0x0000256b => "\xd7",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x0000258c => "\xdd",
     0x00002590 => "\xde",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM864.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM864;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x066a,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00b0,
     0x00b7,
     0x2219,
     0x221a,
     0x2592,
     0x2500,
     0x2502,
     0x253c,
     0x2524,
     0x252c,
     0x251c,
     0x2534,
     0x2510,
     0x250c,
     0x2514,
     0x2518,
     0x03b2,
     0x221e,
     0x03c6,
     0x00b1,
     0x00bd,
     0x00bc,
     0x2248,
     0x00ab,
     0x00bb,
     0xfef7,
     0xfef8,
     0xfffd,
     0xfffd,
     0xfefb,
     0xfefc,
     0xfffd,
     0x00a0,
     0x00ad,
     0xfe82,
     0x00a3,
     0x00a4,
     0xfe84,
     0xfffd,
     0xfffd,
     0xfe8e,
     0xfe8f,
     0xfe95,
     0xfe99,
     0x060c,
     0xfe9d,
     0xfea1,
     0xfea5,
     0x0660,
     0x0661,
     0x0662,
     0x0663,
     0x0664,
     0x0665,
     0x0666,
     0x0667,
     0x0668,
     0x0669,
     0xfed1,
     0x061b,
     0xfeb1,
     0xfeb5,
     0xfeb9,
     0x061f,
     0x00a2,
     0xfe80,
     0xfe81,
     0xfe83,
     0xfe85,
     0xfeca,
     0xfe8b,
     0xfe8d,
     0xfe91,
     0xfe93,
     0xfe97,
     0xfe9b,
     0xfe9f,
     0xfea3,
     0xfea7,
     0xfea9,
     0xfeab,
     0xfead,
     0xfeaf,
     0xfeb3,
     0xfeb7,
     0xfebb,
     0xfebf,
     0xfec1,
     0xfec5,
     0xfecb,
     0xfecf,
     0x00a6,
     0x00ac,
     0x00f7,
     0x00d7,
     0xfec9,
     0x0640,
     0xfed3,
     0xfed7,
     0xfedb,
     0xfedf,
     0xfee3,
     0xfee7,
     0xfeeb,
     0xfeed,
     0xfeef,
     0xfef3,
     0xfebd,
     0xfecc,
     0xfece,
     0xfecd,
     0xfee1,
     0xfe7d,
     0x0651,
     0xfee5,
     0xfee9,
     0xfeec,
     0xfef0,
     0xfef2,
     0xfed0,
     0xfed5,
     0xfef5,
     0xfef6,
     0xfedd,
     0xfed9,
     0xfef1,
     0x25a0,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\xd9\xaa",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\xb0",
     "\xc2\xb7",
     "\xe2\x88\x99",
     "\xe2\x88\x9a",
     "\xe2\x96\x92",
     "\xe2\x94\x80",
     "\xe2\x94\x82",
     "\xe2\x94\xbc",
     "\xe2\x94\xa4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\xb4",
     "\xe2\x94\x90",
     "\xe2\x94\x8c",
     "\xe2\x94\x94",
     "\xe2\x94\x98",
     "\xce\xb2",
     "\xe2\x88\x9e",
     "\xcf\x86",
     "\xc2\xb1",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xe2\x89\x88",
     "\xc2\xab",
     "\xc2\xbb",
     "\xef\xbb\xb7",
     "\xef\xbb\xb8",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbb\xbb",
     "\xef\xbb\xbc",
     "\xef\xbf\xbd",
     "\xc2\xa0",
     "\xc2\xad",
     "\xef\xba\x82",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xef\xba\x84",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xba\x8e",
     "\xef\xba\x8f",
     "\xef\xba\x95",
     "\xef\xba\x99",
     "\xd8\x8c",
     "\xef\xba\x9d",
     "\xef\xba\xa1",
     "\xef\xba\xa5",
     "\xd9\xa0",
     "\xd9\xa1",
     "\xd9\xa2",
     "\xd9\xa3",
     "\xd9\xa4",
     "\xd9\xa5",
     "\xd9\xa6",
     "\xd9\xa7",
     "\xd9\xa8",
     "\xd9\xa9",
     "\xef\xbb\x91",
     "\xd8\x9b",
     "\xef\xba\xb1",
     "\xef\xba\xb5",
     "\xef\xba\xb9",
     "\xd8\x9f",
     "\xc2\xa2",
     "\xef\xba\x80",
     "\xef\xba\x81",
     "\xef\xba\x83",
     "\xef\xba\x85",
     "\xef\xbb\x8a",
     "\xef\xba\x8b",
     "\xef\xba\x8d",
     "\xef\xba\x91",
     "\xef\xba\x93",
     "\xef\xba\x97",
     "\xef\xba\x9b",
     "\xef\xba\x9f",
     "\xef\xba\xa3",
     "\xef\xba\xa7",
     "\xef\xba\xa9",
     "\xef\xba\xab",
     "\xef\xba\xad",
     "\xef\xba\xaf",
     "\xef\xba\xb3",
     "\xef\xba\xb7",
     "\xef\xba\xbb",
     "\xef\xba\xbf",
     "\xef\xbb\x81",
     "\xef\xbb\x85",
     "\xef\xbb\x8b",
     "\xef\xbb\x8f",
     "\xc2\xa6",
     "\xc2\xac",
     "\xc3\xb7",
     "\xc3\x97",
     "\xef\xbb\x89",
     "\xd9\x80",
     "\xef\xbb\x93",
     "\xef\xbb\x97",
     "\xef\xbb\x9b",
     "\xef\xbb\x9f",
     "\xef\xbb\xa3",
     "\xef\xbb\xa7",
     "\xef\xbb\xab",
     "\xef\xbb\xad",
     "\xef\xbb\xaf",
     "\xef\xbb\xb3",
     "\xef\xba\xbd",
     "\xef\xbb\x8c",
     "\xef\xbb\x8e",
     "\xef\xbb\x8d",
     "\xef\xbb\xa1",
     "\xef\xb9\xbd",
     "\xd9\x91",
     "\xef\xbb\xa5",
     "\xef\xbb\xa9",
     "\xef\xbb\xac",
     "\xef\xbb\xb0",
     "\xef\xbb\xb2",
     "\xef\xbb\x90",
     "\xef\xbb\x95",
     "\xef\xbb\xb5",
     "\xef\xbb\xb6",
     "\xef\xbb\x9d",
     "\xef\xbb\x99",
     "\xef\xbb\xb1",
     "\xe2\x96\xa0",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x000000a2 => "\xc0",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a6 => "\xdb",
     0x000000ab => "\x97",
     0x000000ac => "\xdc",
     0x000000ad => "\xa1",
     0x000000b0 => "\x80",
     0x000000b1 => "\x93",
     0x000000b7 => "\x81",
     0x000000bb => "\x98",
     0x000000bc => "\x95",
     0x000000bd => "\x94",
     0x000000d7 => "\xde",
     0x000000f7 => "\xdd",
     0x000003b2 => "\x90",
     0x000003c6 => "\x92",
     0x0000060c => "\xac",
     0x0000061b => "\xbb",
     0x0000061f => "\xbf",
     0x00000640 => "\xe0",
     0x00000651 => "\xf1",
     0x00000660 => "\xb0",
     0x00000661 => "\xb1",
     0x00000662 => "\xb2",
     0x00000663 => "\xb3",
     0x00000664 => "\xb4",
     0x00000665 => "\xb5",
     0x00000666 => "\xb6",
     0x00000667 => "\xb7",
     0x00000668 => "\xb8",
     0x00000669 => "\xb9",
     0x0000066a => "\x25",
     0x00002219 => "\x82",
     0x0000221a => "\x83",
     0x0000221e => "\x91",
     0x00002248 => "\x96",
     0x00002500 => "\x85",
     0x00002502 => "\x86",
     0x0000250c => "\x8d",
     0x00002510 => "\x8c",
     0x00002514 => "\x8e",
     0x00002518 => "\x8f",
     0x0000251c => "\x8a",
     0x00002524 => "\x88",
     0x0000252c => "\x89",
     0x00002534 => "\x8b",
     0x0000253c => "\x87",
     0x00002592 => "\x84",
     0x000025a0 => "\xfe",
     0x0000fe7d => "\xf0",
     0x0000fe80 => "\xc1",
     0x0000fe81 => "\xc2",
     0x0000fe82 => "\xa2",
     0x0000fe83 => "\xc3",
     0x0000fe84 => "\xa5",
     0x0000fe85 => "\xc4",
     0x0000fe8b => "\xc6",
     0x0000fe8d => "\xc7",
     0x0000fe8e => "\xa8",
     0x0000fe8f => "\xa9",
     0x0000fe91 => "\xc8",
     0x0000fe93 => "\xc9",
     0x0000fe95 => "\xaa",
     0x0000fe97 => "\xca",
     0x0000fe99 => "\xab",
     0x0000fe9b => "\xcb",
     0x0000fe9d => "\xad",
     0x0000fe9f => "\xcc",
     0x0000fea1 => "\xae",
     0x0000fea3 => "\xcd",
     0x0000fea5 => "\xaf",
     0x0000fea7 => "\xce",
     0x0000fea9 => "\xcf",
     0x0000feab => "\xd0",
     0x0000fead => "\xd1",
     0x0000feaf => "\xd2",
     0x0000feb1 => "\xbc",
     0x0000feb3 => "\xd3",
     0x0000feb5 => "\xbd",
     0x0000feb7 => "\xd4",
     0x0000feb9 => "\xbe",
     0x0000febb => "\xd5",
     0x0000febd => "\xeb",
     0x0000febf => "\xd6",
     0x0000fec1 => "\xd7",
     0x0000fec5 => "\xd8",
     0x0000fec9 => "\xdf",
     0x0000feca => "\xc5",
     0x0000fecb => "\xd9",
     0x0000fecc => "\xec",
     0x0000fecd => "\xee",
     0x0000fece => "\xed",
     0x0000fecf => "\xda",
     0x0000fed0 => "\xf7",
     0x0000fed1 => "\xba",
     0x0000fed3 => "\xe1",
     0x0000fed5 => "\xf8",
     0x0000fed7 => "\xe2",
     0x0000fed9 => "\xfc",
     0x0000fedb => "\xe3",
     0x0000fedd => "\xfb",
     0x0000fedf => "\xe4",
     0x0000fee1 => "\xef",
     0x0000fee3 => "\xe5",
     0x0000fee5 => "\xf2",
     0x0000fee7 => "\xe6",
     0x0000fee9 => "\xf3",
     0x0000feeb => "\xe7",
     0x0000feec => "\xf4",
     0x0000feed => "\xe8",
     0x0000feef => "\xe9",
     0x0000fef0 => "\xf5",
     0x0000fef1 => "\xfd",
     0x0000fef2 => "\xf6",
     0x0000fef3 => "\xea",
     0x0000fef5 => "\xf9",
     0x0000fef6 => "\xfa",
     0x0000fef7 => "\x99",
     0x0000fef8 => "\x9a",
     0x0000fefb => "\x9d",
     0x0000fefc => "\x9e",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM865.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM865;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c7,
     0x00fc,
     0x00e9,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e5,
     0x00e7,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ef,
     0x00ee,
     0x00ec,
     0x00c4,
     0x00c5,
     0x00c9,
     0x00e6,
     0x00c6,
     0x00f4,
     0x00f6,
     0x00f2,
     0x00fb,
     0x00f9,
     0x00ff,
     0x00d6,
     0x00dc,
     0x00f8,
     0x00a3,
     0x00d8,
     0x20a7,
     0x0192,
     0x00e1,
     0x00ed,
     0x00f3,
     0x00fa,
     0x00f1,
     0x00d1,
     0x00aa,
     0x00ba,
     0x00bf,
     0x2310,
     0x00ac,
     0x00bd,
     0x00bc,
     0x00a1,
     0x00ab,
     0x00a4,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x2561,
     0x2562,
     0x2556,
     0x2555,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x255c,
     0x255b,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x255e,
     0x255f,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x2567,
     0x2568,
     0x2564,
     0x2565,
     0x2559,
     0x2558,
     0x2552,
     0x2553,
     0x256b,
     0x256a,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x258c,
     0x2590,
     0x2580,
     0x03b1,
     0x00df,
     0x0393,
     0x03c0,
     0x03a3,
     0x03c3,
     0x00b5,
     0x03c4,
     0x03a6,
     0x0398,
     0x03a9,
     0x03b4,
     0x221e,
     0x03c6,
     0x03b5,
     0x2229,
     0x2261,
     0x00b1,
     0x2265,
     0x2264,
     0x2320,
     0x2321,
     0x00f7,
     0x2248,
     0x00b0,
     0x2219,
     0x00b7,
     0x221a,
     0x207f,
     0x00b2,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x87",
     "\xc3\xbc",
     "\xc3\xa9",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xaf",
     "\xc3\xae",
     "\xc3\xac",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x89",
     "\xc3\xa6",
     "\xc3\x86",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb2",
     "\xc3\xbb",
     "\xc3\xb9",
     "\xc3\xbf",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xb8",
     "\xc2\xa3",
     "\xc3\x98",
     "\xe2\x82\xa7",
     "\xc6\x92",
     "\xc3\xa1",
     "\xc3\xad",
     "\xc3\xb3",
     "\xc3\xba",
     "\xc3\xb1",
     "\xc3\x91",
     "\xc2\xaa",
     "\xc2\xba",
     "\xc2\xbf",
     "\xe2\x8c\x90",
     "\xc2\xac",
     "\xc2\xbd",
     "\xc2\xbc",
     "\xc2\xa1",
     "\xc2\xab",
     "\xc2\xa4",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xe2\x95\xa1",
     "\xe2\x95\xa2",
     "\xe2\x95\x96",
     "\xe2\x95\x95",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xe2\x95\x9c",
     "\xe2\x95\x9b",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xe2\x95\x9e",
     "\xe2\x95\x9f",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xe2\x95\xa7",
     "\xe2\x95\xa8",
     "\xe2\x95\xa4",
     "\xe2\x95\xa5",
     "\xe2\x95\x99",
     "\xe2\x95\x98",
     "\xe2\x95\x92",
     "\xe2\x95\x93",
     "\xe2\x95\xab",
     "\xe2\x95\xaa",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xe2\x96\x8c",
     "\xe2\x96\x90",
     "\xe2\x96\x80",
     "\xce\xb1",
     "\xc3\x9f",
     "\xce\x93",
     "\xcf\x80",
     "\xce\xa3",
     "\xcf\x83",
     "\xc2\xb5",
     "\xcf\x84",
     "\xce\xa6",
     "\xce\x98",
     "\xce\xa9",
     "\xce\xb4",
     "\xe2\x88\x9e",
     "\xcf\x86",
     "\xce\xb5",
     "\xe2\x88\xa9",
     "\xe2\x89\xa1",
     "\xc2\xb1",
     "\xe2\x89\xa5",
     "\xe2\x89\xa4",
     "\xe2\x8c\xa0",
     "\xe2\x8c\xa1",
     "\xc3\xb7",
     "\xe2\x89\x88",
     "\xc2\xb0",
     "\xe2\x88\x99",
     "\xc2\xb7",
     "\xe2\x88\x9a",
     "\xe2\x81\xbf",
     "\xc2\xb2",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a1 => "\xad",
     0x000000a3 => "\x9c",
     0x000000a4 => "\xaf",
     0x000000aa => "\xa6",
     0x000000ab => "\xae",
     0x000000ac => "\xaa",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b2 => "\xfd",
     0x000000b5 => "\xe6",
     0x000000b7 => "\xfa",
     0x000000ba => "\xa7",
     0x000000bc => "\xac",
     0x000000bd => "\xab",
     0x000000bf => "\xa8",
     0x000000c4 => "\x8e",
     0x000000c5 => "\x8f",
     0x000000c6 => "\x92",
     0x000000c7 => "\x80",
     0x000000c9 => "\x90",
     0x000000d1 => "\xa5",
     0x000000d6 => "\x99",
     0x000000d8 => "\x9d",
     0x000000dc => "\x9a",
     0x000000df => "\xe1",
     0x000000e0 => "\x85",
     0x000000e1 => "\xa0",
     0x000000e2 => "\x83",
     0x000000e4 => "\x84",
     0x000000e5 => "\x86",
     0x000000e6 => "\x91",
     0x000000e7 => "\x87",
     0x000000e8 => "\x8a",
     0x000000e9 => "\x82",
     0x000000ea => "\x88",
     0x000000eb => "\x89",
     0x000000ec => "\x8d",
     0x000000ed => "\xa1",
     0x000000ee => "\x8c",
     0x000000ef => "\x8b",
     0x000000f1 => "\xa4",
     0x000000f2 => "\x95",
     0x000000f3 => "\xa2",
     0x000000f4 => "\x93",
     0x000000f6 => "\x94",
     0x000000f7 => "\xf6",
     0x000000f8 => "\x9b",
     0x000000f9 => "\x97",
     0x000000fa => "\xa3",
     0x000000fb => "\x96",
     0x000000fc => "\x81",
     0x000000ff => "\x98",
     0x00000192 => "\x9f",
     0x00000393 => "\xe2",
     0x00000398 => "\xe9",
     0x000003a3 => "\xe4",
     0x000003a6 => "\xe8",
     0x000003a9 => "\xea",
     0x000003b1 => "\xe0",
     0x000003b4 => "\xeb",
     0x000003b5 => "\xee",
     0x000003c0 => "\xe3",
     0x000003c3 => "\xe5",
     0x000003c4 => "\xe7",
     0x000003c6 => "\xed",
     0x0000207f => "\xfc",
     0x000020a7 => "\x9e",
     0x00002219 => "\xf9",
     0x0000221a => "\xfb",
     0x0000221e => "\xec",
     0x00002229 => "\xef",
     0x00002248 => "\xf7",
     0x00002261 => "\xf0",
     0x00002264 => "\xf3",
     0x00002265 => "\xf2",
     0x00002310 => "\xa9",
     0x00002320 => "\xf4",
     0x00002321 => "\xf5",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002552 => "\xd5",
     0x00002553 => "\xd6",
     0x00002554 => "\xc9",
     0x00002555 => "\xb8",
     0x00002556 => "\xb7",
     0x00002557 => "\xbb",
     0x00002558 => "\xd4",
     0x00002559 => "\xd3",
     0x0000255a => "\xc8",
     0x0000255b => "\xbe",
     0x0000255c => "\xbd",
     0x0000255d => "\xbc",
     0x0000255e => "\xc6",
     0x0000255f => "\xc7",
     0x00002560 => "\xcc",
     0x00002561 => "\xb5",
     0x00002562 => "\xb6",
     0x00002563 => "\xb9",
     0x00002564 => "\xd1",
     0x00002565 => "\xd2",
     0x00002566 => "\xcb",
     0x00002567 => "\xcf",
     0x00002568 => "\xd0",
     0x00002569 => "\xca",
     0x0000256a => "\xd8",
     0x0000256b => "\xd7",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x0000258c => "\xdd",
     0x00002590 => "\xde",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM866.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM866;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0410,
     0x0411,
     0x0412,
     0x0413,
     0x0414,
     0x0415,
     0x0416,
     0x0417,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0424,
     0x0425,
     0x0426,
     0x0427,
     0x0428,
     0x0429,
     0x042a,
     0x042b,
     0x042c,
     0x042d,
     0x042e,
     0x042f,
     0x0430,
     0x0431,
     0x0432,
     0x0433,
     0x0434,
     0x0435,
     0x0436,
     0x0437,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x2561,
     0x2562,
     0x2556,
     0x2555,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x255c,
     0x255b,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x255e,
     0x255f,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x2567,
     0x2568,
     0x2564,
     0x2565,
     0x2559,
     0x2558,
     0x2552,
     0x2553,
     0x256b,
     0x256a,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x258c,
     0x2590,
     0x2580,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0444,
     0x0445,
     0x0446,
     0x0447,
     0x0448,
     0x0449,
     0x044a,
     0x044b,
     0x044c,
     0x044d,
     0x044e,
     0x044f,
     0x0401,
     0x0451,
     0x0404,
     0x0454,
     0x0407,
     0x0457,
     0x040e,
     0x045e,
     0x00b0,
     0x2219,
     0x00b7,
     0x221a,
     0x2116,
     0x00a4,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\x92",
     "\xd0\x93",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\x96",
     "\xd0\x97",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\xa4",
     "\xd0\xa5",
     "\xd0\xa6",
     "\xd0\xa7",
     "\xd0\xa8",
     "\xd0\xa9",
     "\xd0\xaa",
     "\xd0\xab",
     "\xd0\xac",
     "\xd0\xad",
     "\xd0\xae",
     "\xd0\xaf",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd0\xb2",
     "\xd0\xb3",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd0\xb6",
     "\xd0\xb7",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xe2\x95\xa1",
     "\xe2\x95\xa2",
     "\xe2\x95\x96",
     "\xe2\x95\x95",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xe2\x95\x9c",
     "\xe2\x95\x9b",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xe2\x95\x9e",
     "\xe2\x95\x9f",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xe2\x95\xa7",
     "\xe2\x95\xa8",
     "\xe2\x95\xa4",
     "\xe2\x95\xa5",
     "\xe2\x95\x99",
     "\xe2\x95\x98",
     "\xe2\x95\x92",
     "\xe2\x95\x93",
     "\xe2\x95\xab",
     "\xe2\x95\xaa",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xe2\x96\x8c",
     "\xe2\x96\x90",
     "\xe2\x96\x80",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd1\x84",
     "\xd1\x85",
     "\xd1\x86",
     "\xd1\x87",
     "\xd1\x88",
     "\xd1\x89",
     "\xd1\x8a",
     "\xd1\x8b",
     "\xd1\x8c",
     "\xd1\x8d",
     "\xd1\x8e",
     "\xd1\x8f",
     "\xd0\x81",
     "\xd1\x91",
     "\xd0\x84",
     "\xd1\x94",
     "\xd0\x87",
     "\xd1\x97",
     "\xd0\x8e",
     "\xd1\x9e",
     "\xc2\xb0",
     "\xe2\x88\x99",
     "\xc2\xb7",
     "\xe2\x88\x9a",
     "\xe2\x84\x96",
     "\xc2\xa4",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a4 => "\xfd",
     0x000000b0 => "\xf8",
     0x000000b7 => "\xfa",
     0x00000401 => "\xf0",
     0x00000404 => "\xf2",
     0x00000407 => "\xf4",
     0x0000040e => "\xf6",
     0x00000410 => "\x80",
     0x00000411 => "\x81",
     0x00000412 => "\x82",
     0x00000413 => "\x83",
     0x00000414 => "\x84",
     0x00000415 => "\x85",
     0x00000416 => "\x86",
     0x00000417 => "\x87",
     0x00000418 => "\x88",
     0x00000419 => "\x89",
     0x0000041a => "\x8a",
     0x0000041b => "\x8b",
     0x0000041c => "\x8c",
     0x0000041d => "\x8d",
     0x0000041e => "\x8e",
     0x0000041f => "\x8f",
     0x00000420 => "\x90",
     0x00000421 => "\x91",
     0x00000422 => "\x92",
     0x00000423 => "\x93",
     0x00000424 => "\x94",
     0x00000425 => "\x95",
     0x00000426 => "\x96",
     0x00000427 => "\x97",
     0x00000428 => "\x98",
     0x00000429 => "\x99",
     0x0000042a => "\x9a",
     0x0000042b => "\x9b",
     0x0000042c => "\x9c",
     0x0000042d => "\x9d",
     0x0000042e => "\x9e",
     0x0000042f => "\x9f",
     0x00000430 => "\xa0",
     0x00000431 => "\xa1",
     0x00000432 => "\xa2",
     0x00000433 => "\xa3",
     0x00000434 => "\xa4",
     0x00000435 => "\xa5",
     0x00000436 => "\xa6",
     0x00000437 => "\xa7",
     0x00000438 => "\xa8",
     0x00000439 => "\xa9",
     0x0000043a => "\xaa",
     0x0000043b => "\xab",
     0x0000043c => "\xac",
     0x0000043d => "\xad",
     0x0000043e => "\xae",
     0x0000043f => "\xaf",
     0x00000440 => "\xe0",
     0x00000441 => "\xe1",
     0x00000442 => "\xe2",
     0x00000443 => "\xe3",
     0x00000444 => "\xe4",
     0x00000445 => "\xe5",
     0x00000446 => "\xe6",
     0x00000447 => "\xe7",
     0x00000448 => "\xe8",
     0x00000449 => "\xe9",
     0x0000044a => "\xea",
     0x0000044b => "\xeb",
     0x0000044c => "\xec",
     0x0000044d => "\xed",
     0x0000044e => "\xee",
     0x0000044f => "\xef",
     0x00000451 => "\xf1",
     0x00000454 => "\xf3",
     0x00000457 => "\xf5",
     0x0000045e => "\xf7",
     0x00002116 => "\xfc",
     0x00002219 => "\xf9",
     0x0000221a => "\xfb",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002552 => "\xd5",
     0x00002553 => "\xd6",
     0x00002554 => "\xc9",
     0x00002555 => "\xb8",
     0x00002556 => "\xb7",
     0x00002557 => "\xbb",
     0x00002558 => "\xd4",
     0x00002559 => "\xd3",
     0x0000255a => "\xc8",
     0x0000255b => "\xbe",
     0x0000255c => "\xbd",
     0x0000255d => "\xbc",
     0x0000255e => "\xc6",
     0x0000255f => "\xc7",
     0x00002560 => "\xcc",
     0x00002561 => "\xb5",
     0x00002562 => "\xb6",
     0x00002563 => "\xb9",
     0x00002564 => "\xd1",
     0x00002565 => "\xd2",
     0x00002566 => "\xcb",
     0x00002567 => "\xcf",
     0x00002568 => "\xd0",
     0x00002569 => "\xca",
     0x0000256a => "\xd8",
     0x0000256b => "\xd7",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x0000258c => "\xdd",
     0x00002590 => "\xde",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM868.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM868;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0660,
     0x0661,
     0x0662,
     0x0663,
     0x0664,
     0x0665,
     0x0666,
     0x0667,
     0x0668,
     0x0669,
     0x060c,
     0x061b,
     0x061f,
     0x0622,
     0x0627,
     0xfe8e,
     0xe016,
     0x0628,
     0xfe91,
     0x067e,
     0xfffd,
     0x0629,
     0x062a,
     0xfe97,
     0xfffd,
     0xfffd,
     0x062b,
     0xfe9b,
     0x062c,
     0xfe9f,
     0xfffd,
     0xfffd,
     0x062d,
     0xfea3,
     0x062e,
     0xfea7,
     0x062f,
     0xfffd,
     0x0630,
     0x0631,
     0xfffd,
     0x0632,
     0xfffd,
     0x0633,
     0xfeb3,
     0x0634,
     0x00ab,
     0x00bb,
     0xfeb7,
     0x0635,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0xfebb,
     0x0636,
     0xfebf,
     0x0637,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x0638,
     0x0639,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0xfeca,
     0xfecb,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0xfecc,
     0x063a,
     0xfece,
     0xfecf,
     0xfed0,
     0x0641,
     0xfed3,
     0x0642,
     0xfed7,
     0xfeda,
     0x2518,
     0x250c,
     0x2588,
     0x2580,
     0xfedb,
     0xfffd,
     0x2584,
     0xfffd,
     0x0644,
     0xfede,
     0xfee0,
     0x0645,
     0xfee3,
     0xfffd,
     0x0646,
     0xfee7,
     0xfffd,
     0x0648,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0621,
     0x00ad,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0651,
     0xfe7d,
     0xfffd,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xd9\xa0",
     "\xd9\xa1",
     "\xd9\xa2",
     "\xd9\xa3",
     "\xd9\xa4",
     "\xd9\xa5",
     "\xd9\xa6",
     "\xd9\xa7",
     "\xd9\xa8",
     "\xd9\xa9",
     "\xd8\x8c",
     "\xd8\x9b",
     "\xd8\x9f",
     "\xd8\xa2",
     "\xd8\xa7",
     "\xef\xba\x8e",
     "\xee\x80\x96",
     "\xd8\xa8",
     "\xef\xba\x91",
     "\xd9\xbe",
     "\xef\xbf\xbd",
     "\xd8\xa9",
     "\xd8\xaa",
     "\xef\xba\x97",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd8\xab",
     "\xef\xba\x9b",
     "\xd8\xac",
     "\xef\xba\x9f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd8\xad",
     "\xef\xba\xa3",
     "\xd8\xae",
     "\xef\xba\xa7",
     "\xd8\xaf",
     "\xef\xbf\xbd",
     "\xd8\xb0",
     "\xd8\xb1",
     "\xef\xbf\xbd",
     "\xd8\xb2",
     "\xef\xbf\xbd",
     "\xd8\xb3",
     "\xef\xba\xb3",
     "\xd8\xb4",
     "\xc2\xab",
     "\xc2\xbb",
     "\xef\xba\xb7",
     "\xd8\xb5",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xef\xba\xbb",
     "\xd8\xb6",
     "\xef\xba\xbf",
     "\xd8\xb7",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xd8\xb8",
     "\xd8\xb9",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xef\xbb\x8a",
     "\xef\xbb\x8b",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xef\xbb\x8c",
     "\xd8\xba",
     "\xef\xbb\x8e",
     "\xef\xbb\x8f",
     "\xef\xbb\x90",
     "\xd9\x81",
     "\xef\xbb\x93",
     "\xd9\x82",
     "\xef\xbb\x97",
     "\xef\xbb\x9a",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x80",
     "\xef\xbb\x9b",
     "\xef\xbf\xbd",
     "\xe2\x96\x84",
     "\xef\xbf\xbd",
     "\xd9\x84",
     "\xef\xbb\x9e",
     "\xef\xbb\xa0",
     "\xd9\x85",
     "\xef\xbb\xa3",
     "\xef\xbf\xbd",
     "\xd9\x86",
     "\xef\xbb\xa7",
     "\xef\xbf\xbd",
     "\xd9\x88",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd8\xa1",
     "\xc2\xad",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd9\x91",
     "\xef\xb9\xbd",
     "\xef\xbf\xbd",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000ab => "\xae",
     0x000000ad => "\xf2",
     0x000000bb => "\xaf",
     0x0000060c => "\x8a",
     0x0000061b => "\x8b",
     0x0000061f => "\x8c",
     0x00000621 => "\xf1",
     0x00000622 => "\x8d",
     0x00000627 => "\x8e",
     0x00000628 => "\x91",
     0x00000629 => "\x95",
     0x0000062a => "\x96",
     0x0000062b => "\x9a",
     0x0000062c => "\x9c",
     0x0000062d => "\xa0",
     0x0000062e => "\xa2",
     0x0000062f => "\xa4",
     0x00000630 => "\xa6",
     0x00000631 => "\xa7",
     0x00000632 => "\xa9",
     0x00000633 => "\xab",
     0x00000634 => "\xad",
     0x00000635 => "\xb1",
     0x00000636 => "\xb8",
     0x00000637 => "\xba",
     0x00000638 => "\xbf",
     0x00000639 => "\xc0",
     0x0000063a => "\xd2",
     0x00000641 => "\xd6",
     0x00000642 => "\xd8",
     0x00000644 => "\xe3",
     0x00000645 => "\xe6",
     0x00000646 => "\xe9",
     0x00000648 => "\xec",
     0x00000651 => "\xfb",
     0x00000660 => "\x80",
     0x00000661 => "\x81",
     0x00000662 => "\x82",
     0x00000663 => "\x83",
     0x00000664 => "\x84",
     0x00000665 => "\x85",
     0x00000666 => "\x86",
     0x00000667 => "\x87",
     0x00000668 => "\x88",
     0x00000669 => "\x89",
     0x0000067e => "\x93",
     0x00002500 => "\xc6",
     0x00002502 => "\xb5",
     0x0000250c => "\xdc",
     0x00002510 => "\xc1",
     0x00002514 => "\xc2",
     0x00002518 => "\xdb",
     0x0000251c => "\xc5",
     0x00002524 => "\xb6",
     0x0000252c => "\xc4",
     0x00002534 => "\xc3",
     0x0000253c => "\xc7",
     0x00002550 => "\xcf",
     0x00002551 => "\xbc",
     0x00002554 => "\xcb",
     0x00002557 => "\xbd",
     0x0000255a => "\xca",
     0x0000255d => "\xbe",
     0x00002560 => "\xce",
     0x00002563 => "\xbb",
     0x00002566 => "\xcd",
     0x00002569 => "\xcc",
     0x0000256c => "\xd0",
     0x00002580 => "\xde",
     0x00002584 => "\xe1",
     0x00002588 => "\xdd",
     0x00002591 => "\xb2",
     0x00002592 => "\xb3",
     0x00002593 => "\xb4",
     0x000025a0 => "\xfe",
     0x0000e016 => "\x90",
     0x0000fe7d => "\xfc",
     0x0000fe8e => "\x8f",
     0x0000fe91 => "\x92",
     0x0000fe97 => "\x97",
     0x0000fe9b => "\x9b",
     0x0000fe9f => "\x9d",
     0x0000fea3 => "\xa1",
     0x0000fea7 => "\xa3",
     0x0000feb3 => "\xac",
     0x0000feb7 => "\xb0",
     0x0000febb => "\xb7",
     0x0000febf => "\xb9",
     0x0000feca => "\xc8",
     0x0000fecb => "\xc9",
     0x0000fecc => "\xd1",
     0x0000fece => "\xd3",
     0x0000fecf => "\xd4",
     0x0000fed0 => "\xd5",
     0x0000fed3 => "\xd7",
     0x0000fed7 => "\xd9",
     0x0000feda => "\xda",
     0x0000fedb => "\xdf",
     0x0000fede => "\xe4",
     0x0000fee0 => "\xe5",
     0x0000fee3 => "\xe7",
     0x0000fee7 => "\xea",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x8c"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM869.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM869;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0386,
     0xfffd,
     0x00b7,
     0x00ac,
     0x00a6,
     0x2018,
     0x2019,
     0x0388,
     0x2015,
     0x0389,
     0x038a,
     0x03aa,
     0x038c,
     0xfffd,
     0xfffd,
     0x038e,
     0x03ab,
     0x00a9,
     0x038f,
     0x00b2,
     0x00b3,
     0x03ac,
     0x00a3,
     0x03ad,
     0x03ae,
     0x03af,
     0x03ca,
     0x0390,
     0x03cc,
     0x03cd,
     0x0391,
     0x0392,
     0x0393,
     0x0394,
     0x0395,
     0x0396,
     0x0397,
     0x00bd,
     0x0398,
     0x0399,
     0x00ab,
     0x00bb,
     0x2591,
     0x2592,
     0x2593,
     0x2502,
     0x2524,
     0x039a,
     0x039b,
     0x039c,
     0x039d,
     0x2563,
     0x2551,
     0x2557,
     0x255d,
     0x039e,
     0x039f,
     0x2510,
     0x2514,
     0x2534,
     0x252c,
     0x251c,
     0x2500,
     0x253c,
     0x03a0,
     0x03a1,
     0x255a,
     0x2554,
     0x2569,
     0x2566,
     0x2560,
     0x2550,
     0x256c,
     0x03a3,
     0x03a4,
     0x03a5,
     0x03a6,
     0x03a7,
     0x03a8,
     0x03a9,
     0x03b1,
     0x03b2,
     0x03b3,
     0x2518,
     0x250c,
     0x2588,
     0x2584,
     0x03b4,
     0x03b5,
     0x2580,
     0x03b6,
     0x03b7,
     0x03b8,
     0x03b9,
     0x03ba,
     0x03bb,
     0x03bc,
     0x03bd,
     0x03be,
     0x03bf,
     0x03c0,
     0x03c1,
     0x03c3,
     0x03c2,
     0x03c4,
     0x0384,
     0x00ad,
     0x00b1,
     0x03c5,
     0x03c6,
     0x03c7,
     0x00a7,
     0x03c8,
     0x0385,
     0x00b0,
     0x00a8,
     0x03c9,
     0x03cb,
     0x03b0,
     0x03ce,
     0x25a0,
     0x00a0,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xce\x86",
     "\xef\xbf\xbd",
     "\xc2\xb7",
     "\xc2\xac",
     "\xc2\xa6",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xce\x88",
     "\xe2\x80\x95",
     "\xce\x89",
     "\xce\x8a",
     "\xce\xaa",
     "\xce\x8c",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xce\x8e",
     "\xce\xab",
     "\xc2\xa9",
     "\xce\x8f",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xce\xac",
     "\xc2\xa3",
     "\xce\xad",
     "\xce\xae",
     "\xce\xaf",
     "\xcf\x8a",
     "\xce\x90",
     "\xcf\x8c",
     "\xcf\x8d",
     "\xce\x91",
     "\xce\x92",
     "\xce\x93",
     "\xce\x94",
     "\xce\x95",
     "\xce\x96",
     "\xce\x97",
     "\xc2\xbd",
     "\xce\x98",
     "\xce\x99",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x94\x82",
     "\xe2\x94\xa4",
     "\xce\x9a",
     "\xce\x9b",
     "\xce\x9c",
     "\xce\x9d",
     "\xe2\x95\xa3",
     "\xe2\x95\x91",
     "\xe2\x95\x97",
     "\xe2\x95\x9d",
     "\xce\x9e",
     "\xce\x9f",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\xb4",
     "\xe2\x94\xac",
     "\xe2\x94\x9c",
     "\xe2\x94\x80",
     "\xe2\x94\xbc",
     "\xce\xa0",
     "\xce\xa1",
     "\xe2\x95\x9a",
     "\xe2\x95\x94",
     "\xe2\x95\xa9",
     "\xe2\x95\xa6",
     "\xe2\x95\xa0",
     "\xe2\x95\x90",
     "\xe2\x95\xac",
     "\xce\xa3",
     "\xce\xa4",
     "\xce\xa5",
     "\xce\xa6",
     "\xce\xa7",
     "\xce\xa8",
     "\xce\xa9",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\xb3",
     "\xe2\x94\x98",
     "\xe2\x94\x8c",
     "\xe2\x96\x88",
     "\xe2\x96\x84",
     "\xce\xb4",
     "\xce\xb5",
     "\xe2\x96\x80",
     "\xce\xb6",
     "\xce\xb7",
     "\xce\xb8",
     "\xce\xb9",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xce\xbd",
     "\xce\xbe",
     "\xce\xbf",
     "\xcf\x80",
     "\xcf\x81",
     "\xcf\x83",
     "\xcf\x82",
     "\xcf\x84",
     "\xce\x84",
     "\xc2\xad",
     "\xc2\xb1",
     "\xcf\x85",
     "\xcf\x86",
     "\xcf\x87",
     "\xc2\xa7",
     "\xcf\x88",
     "\xce\x85",
     "\xc2\xb0",
     "\xc2\xa8",
     "\xcf\x89",
     "\xcf\x8b",
     "\xce\xb0",
     "\xcf\x8e",
     "\xe2\x96\xa0",
     "\xc2\xa0",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xff",
     0x000000a3 => "\x9c",
     0x000000a6 => "\x8a",
     0x000000a7 => "\xf5",
     0x000000a8 => "\xf9",
     0x000000a9 => "\x97",
     0x000000ab => "\xae",
     0x000000ac => "\x89",
     0x000000ad => "\xf0",
     0x000000b0 => "\xf8",
     0x000000b1 => "\xf1",
     0x000000b2 => "\x99",
     0x000000b3 => "\x9a",
     0x000000b7 => "\x88",
     0x000000bb => "\xaf",
     0x000000bd => "\xab",
     0x00000384 => "\xef",
     0x00000385 => "\xf7",
     0x00000386 => "\x86",
     0x00000388 => "\x8d",
     0x00000389 => "\x8f",
     0x0000038a => "\x90",
     0x0000038c => "\x92",
     0x0000038e => "\x95",
     0x0000038f => "\x98",
     0x00000390 => "\xa1",
     0x00000391 => "\xa4",
     0x00000392 => "\xa5",
     0x00000393 => "\xa6",
     0x00000394 => "\xa7",
     0x00000395 => "\xa8",
     0x00000396 => "\xa9",
     0x00000397 => "\xaa",
     0x00000398 => "\xac",
     0x00000399 => "\xad",
     0x0000039a => "\xb5",
     0x0000039b => "\xb6",
     0x0000039c => "\xb7",
     0x0000039d => "\xb8",
     0x0000039e => "\xbd",
     0x0000039f => "\xbe",
     0x000003a0 => "\xc6",
     0x000003a1 => "\xc7",
     0x000003a3 => "\xcf",
     0x000003a4 => "\xd0",
     0x000003a5 => "\xd1",
     0x000003a6 => "\xd2",
     0x000003a7 => "\xd3",
     0x000003a8 => "\xd4",
     0x000003a9 => "\xd5",
     0x000003aa => "\x91",
     0x000003ab => "\x96",
     0x000003ac => "\x9b",
     0x000003ad => "\x9d",
     0x000003ae => "\x9e",
     0x000003af => "\x9f",
     0x000003b0 => "\xfc",
     0x000003b1 => "\xd6",
     0x000003b2 => "\xd7",
     0x000003b3 => "\xd8",
     0x000003b4 => "\xdd",
     0x000003b5 => "\xde",
     0x000003b6 => "\xe0",
     0x000003b7 => "\xe1",
     0x000003b8 => "\xe2",
     0x000003b9 => "\xe3",
     0x000003ba => "\xe4",
     0x000003bb => "\xe5",
     0x000003bc => "\xe6",
     0x000003bd => "\xe7",
     0x000003be => "\xe8",
     0x000003bf => "\xe9",
     0x000003c0 => "\xea",
     0x000003c1 => "\xeb",
     0x000003c2 => "\xed",
     0x000003c3 => "\xec",
     0x000003c4 => "\xee",
     0x000003c5 => "\xf2",
     0x000003c6 => "\xf3",
     0x000003c7 => "\xf4",
     0x000003c8 => "\xf6",
     0x000003c9 => "\xfa",
     0x000003ca => "\xa0",
     0x000003cb => "\xfb",
     0x000003cc => "\xa2",
     0x000003cd => "\xa3",
     0x000003ce => "\xfd",
     0x00002015 => "\x8e",
     0x00002018 => "\x8b",
     0x00002019 => "\x8c",
     0x00002500 => "\xc4",
     0x00002502 => "\xb3",
     0x0000250c => "\xda",
     0x00002510 => "\xbf",
     0x00002514 => "\xc0",
     0x00002518 => "\xd9",
     0x0000251c => "\xc3",
     0x00002524 => "\xb4",
     0x0000252c => "\xc2",
     0x00002534 => "\xc1",
     0x0000253c => "\xc5",
     0x00002550 => "\xcd",
     0x00002551 => "\xba",
     0x00002554 => "\xc9",
     0x00002557 => "\xbb",
     0x0000255a => "\xc8",
     0x0000255d => "\xbc",
     0x00002560 => "\xcc",
     0x00002563 => "\xb9",
     0x00002566 => "\xcb",
     0x00002569 => "\xca",
     0x0000256c => "\xce",
     0x00002580 => "\xdf",
     0x00002584 => "\xdc",
     0x00002588 => "\xdb",
     0x00002591 => "\xb0",
     0x00002592 => "\xb1",
     0x00002593 => "\xb2",
     0x000025a0 => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM870.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM870;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0xfffd,
     0x00e4,
     0xfffd,
     0x00e1,
     0x0103,
     0x010d,
     0x00e7,
     0x0107,
     0x005b,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x00e9,
     0xfffd,
     0x00eb,
     0x016f,
     0x00ed,
     0xfffd,
     0x013e,
     0x013a,
     0x00df,
     0x005d,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0xfffd,
     0x00c4,
     0x02dd,
     0x00c1,
     0xfffd,
     0x010c,
     0x00c7,
     0x0106,
     0x007c,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x02c7,
     0x00c9,
     0xfffd,
     0x00cb,
     0x016e,
     0x00cd,
     0xfffd,
     0x013d,
     0x0139,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0x02d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x015b,
     0x0148,
     0x0111,
     0x00fd,
     0x0159,
     0xfffd,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0142,
     0x0144,
     0x0161,
     0x00b8,
     0x02db,
     0x00a4,
     0x0105,
     0x007e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x015a,
     0x0147,
     0x0110,
     0x00dd,
     0x0158,
     0xfffd,
     0x00b7,
     0x0104,
     0x017c,
     0xfffd,
     0x017b,
     0x00a7,
     0x00b6,
     0x017e,
     0x017a,
     0x017d,
     0x0179,
     0x0143,
     0x0160,
     0x00a8,
     0x00b4,
     0x00d7,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x00f6,
     0x0155,
     0x00f3,
     0x0151,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x011a,
     0x0171,
     0x00fc,
     0x0165,
     0x00fa,
     0x011b,
     0x005c,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x010f,
     0x00d4,
     0x00d6,
     0x0154,
     0x00d3,
     0x0150,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x010e,
     0x0170,
     0x00dc,
     0x0164,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xef\xbf\xbd",
     "\xc3\xa4",
     "\xef\xbf\xbd",
     "\xc3\xa1",
     "\xc4\x83",
     "\xc4\x8d",
     "\xc3\xa7",
     "\xc4\x87",
     "\x5b",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xc3\xa9",
     "\xef\xbf\xbd",
     "\xc3\xab",
     "\xc5\xaf",
     "\xc3\xad",
     "\xef\xbf\xbd",
     "\xc4\xbe",
     "\xc4\xba",
     "\xc3\x9f",
     "\x5d",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xef\xbf\xbd",
     "\xc3\x84",
     "\xcb\x9d",
     "\xc3\x81",
     "\xef\xbf\xbd",
     "\xc4\x8c",
     "\xc3\x87",
     "\xc4\x86",
     "\x7c",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xcb\x87",
     "\xc3\x89",
     "\xef\xbf\xbd",
     "\xc3\x8b",
     "\xc5\xae",
     "\xc3\x8d",
     "\xef\xbf\xbd",
     "\xc4\xbd",
     "\xc4\xb9",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xcb\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc5\x9b",
     "\xc5\x88",
     "\xc4\x91",
     "\xc3\xbd",
     "\xc5\x99",
     "\xef\xbf\xbd",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc5\x82",
     "\xc5\x84",
     "\xc5\xa1",
     "\xc2\xb8",
     "\xcb\x9b",
     "\xc2\xa4",
     "\xc4\x85",
     "\x7e",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc5\x9a",
     "\xc5\x87",
     "\xc4\x90",
     "\xc3\x9d",
     "\xc5\x98",
     "\xef\xbf\xbd",
     "\xc2\xb7",
     "\xc4\x84",
     "\xc5\xbc",
     "\xef\xbf\xbd",
     "\xc5\xbb",
     "\xc2\xa7",
     "\xc2\xb6",
     "\xc5\xbe",
     "\xc5\xba",
     "\xc5\xbd",
     "\xc5\xb9",
     "\xc5\x83",
     "\xc5\xa0",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xc3\x97",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc5\x95",
     "\xc3\xb3",
     "\xc5\x91",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc4\x9a",
     "\xc5\xb1",
     "\xc3\xbc",
     "\xc5\xa5",
     "\xc3\xba",
     "\xc4\x9b",
     "\x5c",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc4\x8f",
     "\xc3\x94",
     "\xc3\x96",
     "\xc5\x94",
     "\xc3\x93",
     "\xc5\x90",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc4\x8e",
     "\xc5\xb0",
     "\xc3\x9c",
     "\xc5\xa4",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x4a",
     0x0000005c => "\xe0",
     0x0000005d => "\x5a",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\x6a",
     0x0000007d => "\xd0",
     0x0000007e => "\xa1",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a4 => "\x9f",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xbd",
     0x000000ad => "\xca",
     0x000000b0 => "\x90",
     0x000000b4 => "\xbe",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb0",
     0x000000b8 => "\x9d",
     0x000000c1 => "\x65",
     0x000000c4 => "\x63",
     0x000000c7 => "\x68",
     0x000000c9 => "\x71",
     0x000000cb => "\x73",
     0x000000cd => "\x75",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d6 => "\xec",
     0x000000d7 => "\xbf",
     0x000000da => "\xfe",
     0x000000dc => "\xfc",
     0x000000dd => "\xad",
     0x000000df => "\x59",
     0x000000e1 => "\x45",
     0x000000e4 => "\x43",
     0x000000e7 => "\x48",
     0x000000e9 => "\x51",
     0x000000eb => "\x53",
     0x000000ed => "\x55",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f6 => "\xcc",
     0x000000f7 => "\xe1",
     0x000000fa => "\xde",
     0x000000fc => "\xdc",
     0x000000fd => "\x8d",
     0x00000103 => "\x46",
     0x00000104 => "\xb1",
     0x00000105 => "\xa0",
     0x00000106 => "\x69",
     0x00000107 => "\x49",
     0x0000010c => "\x67",
     0x0000010d => "\x47",
     0x0000010e => "\xfa",
     0x0000010f => "\xea",
     0x00000110 => "\xac",
     0x00000111 => "\x8c",
     0x0000011a => "\xda",
     0x0000011b => "\xdf",
     0x00000139 => "\x78",
     0x0000013a => "\x58",
     0x0000013d => "\x77",
     0x0000013e => "\x57",
     0x00000142 => "\x9a",
     0x00000143 => "\xbb",
     0x00000144 => "\x9b",
     0x00000147 => "\xab",
     0x00000148 => "\x8b",
     0x00000150 => "\xef",
     0x00000151 => "\xcf",
     0x00000154 => "\xed",
     0x00000155 => "\xcd",
     0x00000158 => "\xae",
     0x00000159 => "\x8e",
     0x0000015a => "\xaa",
     0x0000015b => "\x8a",
     0x00000160 => "\xbc",
     0x00000161 => "\x9c",
     0x00000164 => "\xfd",
     0x00000165 => "\xdd",
     0x0000016e => "\x74",
     0x0000016f => "\x54",
     0x00000170 => "\xfb",
     0x00000171 => "\xdb",
     0x00000179 => "\xba",
     0x0000017a => "\xb8",
     0x0000017b => "\xb4",
     0x0000017c => "\xb2",
     0x0000017d => "\xb9",
     0x0000017e => "\xb7",
     0x000002c7 => "\x70",
     0x000002d8 => "\x80",
     0x000002db => "\x9e",
     0x000002dd => "\x64",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM871.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM871;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e1,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00f1,
     0x00fe,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x00c6,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x00d6,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0x00c3,
     0x00c5,
     0x00c7,
     0x00d1,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00f8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x00f0,
     0x003a,
     0x0023,
     0x00d0,
     0x0027,
     0x003d,
     0x0022,
     0x00d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x00ab,
     0x00bb,
     0x0060,
     0x00fd,
     0x007b,
     0x00b1,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x00aa,
     0x00ba,
     0x007d,
     0x00b8,
     0x005d,
     0x00a4,
     0x00b5,
     0x00f6,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00a1,
     0x00bf,
     0x0040,
     0x00dd,
     0x005b,
     0x00ae,
     0x00a2,
     0x00a3,
     0x00a5,
     0x00b7,
     0x00a9,
     0x00a7,
     0x00b6,
     0x00bc,
     0x00bd,
     0x00be,
     0x00ac,
     0x007c,
     0x00af,
     0x00a8,
     0x005c,
     0x00d7,
     0x00de,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x007e,
     0x00f2,
     0x00f3,
     0x00f5,
     0x00e6,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b9,
     0x00fb,
     0x00fc,
     0x00f9,
     0x00fa,
     0x00ff,
     0x00b4,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x005e,
     0x00d2,
     0x00d3,
     0x00d5,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x00dc,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xb1",
     "\xc3\xbe",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\xc3\x86",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\xc3\x96",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x83",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x91",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc3\xb8",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc3\xb0",
     "\x3a",
     "\x23",
     "\xc3\x90",
     "\x27",
     "\x3d",
     "\x22",
     "\xc3\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc2\xab",
     "\xc2\xbb",
     "\x60",
     "\xc3\xbd",
     "\x7b",
     "\xc2\xb1",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc2\xaa",
     "\xc2\xba",
     "\x7d",
     "\xc2\xb8",
     "\x5d",
     "\xc2\xa4",
     "\xc2\xb5",
     "\xc3\xb6",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc2\xa1",
     "\xc2\xbf",
     "\x40",
     "\xc3\x9d",
     "\x5b",
     "\xc2\xae",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa5",
     "\xc2\xb7",
     "\xc2\xa9",
     "\xc2\xa7",
     "\xc2\xb6",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xac",
     "\x7c",
     "\xc2\xaf",
     "\xc2\xa8",
     "\x5c",
     "\xc3\x97",
     "\xc3\x9e",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\x7e",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb5",
     "\xc3\xa6",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbf",
     "\xc2\xb4",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\x5e",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x95",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\xac",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\xae",
     0x0000005c => "\xbe",
     0x0000005d => "\x9e",
     0x0000005e => "\xec",
     0x0000005f => "\x6d",
     0x00000060 => "\x8c",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\x8e",
     0x0000007c => "\xbb",
     0x0000007d => "\x9c",
     0x0000007e => "\xcc",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000a1 => "\xaa",
     0x000000a2 => "\xb0",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x9f",
     0x000000a5 => "\xb2",
     0x000000a6 => "\x6a",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xbd",
     0x000000a9 => "\xb4",
     0x000000aa => "\x9a",
     0x000000ab => "\x8a",
     0x000000ac => "\xba",
     0x000000ad => "\xca",
     0x000000ae => "\xaf",
     0x000000af => "\xbc",
     0x000000b0 => "\x90",
     0x000000b1 => "\x8f",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xe0",
     0x000000b5 => "\xa0",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb3",
     0x000000b8 => "\x9d",
     0x000000b9 => "\xda",
     0x000000ba => "\x9b",
     0x000000bb => "\x8b",
     0x000000bc => "\xb7",
     0x000000bd => "\xb8",
     0x000000be => "\xb9",
     0x000000bf => "\xab",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c3 => "\x66",
     0x000000c4 => "\x63",
     0x000000c5 => "\x67",
     0x000000c6 => "\x5a",
     0x000000c7 => "\x68",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d0 => "\x7c",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d5 => "\xef",
     0x000000d6 => "\x5f",
     0x000000d7 => "\xbf",
     0x000000d8 => "\x80",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\xfc",
     0x000000dd => "\xad",
     0x000000de => "\xc0",
     0x000000df => "\x59",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e3 => "\x46",
     0x000000e4 => "\x43",
     0x000000e5 => "\x47",
     0x000000e6 => "\xd0",
     0x000000e7 => "\x48",
     0x000000e8 => "\x54",
     0x000000e9 => "\x51",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f0 => "\x79",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f5 => "\xcf",
     0x000000f6 => "\xa1",
     0x000000f7 => "\xe1",
     0x000000f8 => "\x70",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xdc",
     0x000000fd => "\x8d",
     0x000000fe => "\x4a",
     0x000000ff => "\xdf",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM874.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM874;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x20ac,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x2026,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a0,
     0x0e01,
     0x0e02,
     0x0e03,
     0x0e04,
     0x0e05,
     0x0e06,
     0x0e07,
     0x0e08,
     0x0e09,
     0x0e0a,
     0x0e0b,
     0x0e0c,
     0x0e0d,
     0x0e0e,
     0x0e0f,
     0x0e10,
     0x0e11,
     0x0e12,
     0x0e13,
     0x0e14,
     0x0e15,
     0x0e16,
     0x0e17,
     0x0e18,
     0x0e19,
     0x0e1a,
     0x0e1b,
     0x0e1c,
     0x0e1d,
     0x0e1e,
     0x0e1f,
     0x0e20,
     0x0e21,
     0x0e22,
     0x0e23,
     0x0e24,
     0x0e25,
     0x0e26,
     0x0e27,
     0x0e28,
     0x0e29,
     0x0e2a,
     0x0e2b,
     0x0e2c,
     0x0e2d,
     0x0e2e,
     0x0e2f,
     0x0e30,
     0x0e31,
     0x0e32,
     0x0e33,
     0x0e34,
     0x0e35,
     0x0e36,
     0x0e37,
     0x0e38,
     0x0e39,
     0x0e3a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0e3f,
     0x0e40,
     0x0e41,
     0x0e42,
     0x0e43,
     0x0e44,
     0x0e45,
     0x0e46,
     0x0e47,
     0x0e48,
     0x0e49,
     0x0e4a,
     0x0e4b,
     0x0e4c,
     0x0e4d,
     0x0e4e,
     0x0e4f,
     0x0e50,
     0x0e51,
     0x0e52,
     0x0e53,
     0x0e54,
     0x0e55,
     0x0e56,
     0x0e57,
     0x0e58,
     0x0e59,
     0x0e5a,
     0x0e5b,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe2\x82\xac",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\xa6",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa0",
     "\xe0\xb8\x81",
     "\xe0\xb8\x82",
     "\xe0\xb8\x83",
     "\xe0\xb8\x84",
     "\xe0\xb8\x85",
     "\xe0\xb8\x86",
     "\xe0\xb8\x87",
     "\xe0\xb8\x88",
     "\xe0\xb8\x89",
     "\xe0\xb8\x8a",
     "\xe0\xb8\x8b",
     "\xe0\xb8\x8c",
     "\xe0\xb8\x8d",
     "\xe0\xb8\x8e",
     "\xe0\xb8\x8f",
     "\xe0\xb8\x90",
     "\xe0\xb8\x91",
     "\xe0\xb8\x92",
     "\xe0\xb8\x93",
     "\xe0\xb8\x94",
     "\xe0\xb8\x95",
     "\xe0\xb8\x96",
     "\xe0\xb8\x97",
     "\xe0\xb8\x98",
     "\xe0\xb8\x99",
     "\xe0\xb8\x9a",
     "\xe0\xb8\x9b",
     "\xe0\xb8\x9c",
     "\xe0\xb8\x9d",
     "\xe0\xb8\x9e",
     "\xe0\xb8\x9f",
     "\xe0\xb8\xa0",
     "\xe0\xb8\xa1",
     "\xe0\xb8\xa2",
     "\xe0\xb8\xa3",
     "\xe0\xb8\xa4",
     "\xe0\xb8\xa5",
     "\xe0\xb8\xa6",
     "\xe0\xb8\xa7",
     "\xe0\xb8\xa8",
     "\xe0\xb8\xa9",
     "\xe0\xb8\xaa",
     "\xe0\xb8\xab",
     "\xe0\xb8\xac",
     "\xe0\xb8\xad",
     "\xe0\xb8\xae",
     "\xe0\xb8\xaf",
     "\xe0\xb8\xb0",
     "\xe0\xb8\xb1",
     "\xe0\xb8\xb2",
     "\xe0\xb8\xb3",
     "\xe0\xb8\xb4",
     "\xe0\xb8\xb5",
     "\xe0\xb8\xb6",
     "\xe0\xb8\xb7",
     "\xe0\xb8\xb8",
     "\xe0\xb8\xb9",
     "\xe0\xb8\xba",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe0\xb8\xbf",
     "\xe0\xb9\x80",
     "\xe0\xb9\x81",
     "\xe0\xb9\x82",
     "\xe0\xb9\x83",
     "\xe0\xb9\x84",
     "\xe0\xb9\x85",
     "\xe0\xb9\x86",
     "\xe0\xb9\x87",
     "\xe0\xb9\x88",
     "\xe0\xb9\x89",
     "\xe0\xb9\x8a",
     "\xe0\xb9\x8b",
     "\xe0\xb9\x8c",
     "\xe0\xb9\x8d",
     "\xe0\xb9\x8e",
     "\xe0\xb9\x8f",
     "\xe0\xb9\x90",
     "\xe0\xb9\x91",
     "\xe0\xb9\x92",
     "\xe0\xb9\x93",
     "\xe0\xb9\x94",
     "\xe0\xb9\x95",
     "\xe0\xb9\x96",
     "\xe0\xb9\x97",
     "\xe0\xb9\x98",
     "\xe0\xb9\x99",
     "\xe0\xb9\x9a",
     "\xe0\xb9\x9b",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x00000e01 => "\xa1",
     0x00000e02 => "\xa2",
     0x00000e03 => "\xa3",
     0x00000e04 => "\xa4",
     0x00000e05 => "\xa5",
     0x00000e06 => "\xa6",
     0x00000e07 => "\xa7",
     0x00000e08 => "\xa8",
     0x00000e09 => "\xa9",
     0x00000e0a => "\xaa",
     0x00000e0b => "\xab",
     0x00000e0c => "\xac",
     0x00000e0d => "\xad",
     0x00000e0e => "\xae",
     0x00000e0f => "\xaf",
     0x00000e10 => "\xb0",
     0x00000e11 => "\xb1",
     0x00000e12 => "\xb2",
     0x00000e13 => "\xb3",
     0x00000e14 => "\xb4",
     0x00000e15 => "\xb5",
     0x00000e16 => "\xb6",
     0x00000e17 => "\xb7",
     0x00000e18 => "\xb8",
     0x00000e19 => "\xb9",
     0x00000e1a => "\xba",
     0x00000e1b => "\xbb",
     0x00000e1c => "\xbc",
     0x00000e1d => "\xbd",
     0x00000e1e => "\xbe",
     0x00000e1f => "\xbf",
     0x00000e20 => "\xc0",
     0x00000e21 => "\xc1",
     0x00000e22 => "\xc2",
     0x00000e23 => "\xc3",
     0x00000e24 => "\xc4",
     0x00000e25 => "\xc5",
     0x00000e26 => "\xc6",
     0x00000e27 => "\xc7",
     0x00000e28 => "\xc8",
     0x00000e29 => "\xc9",
     0x00000e2a => "\xca",
     0x00000e2b => "\xcb",
     0x00000e2c => "\xcc",
     0x00000e2d => "\xcd",
     0x00000e2e => "\xce",
     0x00000e2f => "\xcf",
     0x00000e30 => "\xd0",
     0x00000e31 => "\xd1",
     0x00000e32 => "\xd2",
     0x00000e33 => "\xd3",
     0x00000e34 => "\xd4",
     0x00000e35 => "\xd5",
     0x00000e36 => "\xd6",
     0x00000e37 => "\xd7",
     0x00000e38 => "\xd8",
     0x00000e39 => "\xd9",
     0x00000e3a => "\xda",
     0x00000e3f => "\xdf",
     0x00000e40 => "\xe0",
     0x00000e41 => "\xe1",
     0x00000e42 => "\xe2",
     0x00000e43 => "\xe3",
     0x00000e44 => "\xe4",
     0x00000e45 => "\xe5",
     0x00000e46 => "\xe6",
     0x00000e47 => "\xe7",
     0x00000e48 => "\xe8",
     0x00000e49 => "\xe9",
     0x00000e4a => "\xea",
     0x00000e4b => "\xeb",
     0x00000e4c => "\xec",
     0x00000e4d => "\xed",
     0x00000e4e => "\xee",
     0x00000e4f => "\xef",
     0x00000e50 => "\xf0",
     0x00000e51 => "\xf1",
     0x00000e52 => "\xf2",
     0x00000e53 => "\xf3",
     0x00000e54 => "\xf4",
     0x00000e55 => "\xf5",
     0x00000e56 => "\xf6",
     0x00000e57 => "\xf7",
     0x00000e58 => "\xf8",
     0x00000e59 => "\xf9",
     0x00000e5a => "\xfa",
     0x00000e5b => "\xfb",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x000020ac => "\x80",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM875.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM875;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x0391,
     0x0392,
     0x0393,
     0x0394,
     0x0395,
     0x0396,
     0x0397,
     0x0398,
     0x0399,
     0x005b,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x039a,
     0x039b,
     0x039c,
     0x039d,
     0x039e,
     0x039f,
     0x03a0,
     0x03a1,
     0x03a3,
     0x005d,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x03a4,
     0x03a5,
     0x03a6,
     0x03a7,
     0x03a8,
     0x03a9,
     0x03aa,
     0x03ab,
     0xfffd,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x00a8,
     0x0386,
     0x0388,
     0x0389,
     0x2207,
     0x038a,
     0x038c,
     0x038e,
     0x038f,
     0x0060,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0x0385,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x03b1,
     0x03b2,
     0x03b3,
     0x03b4,
     0x03b5,
     0x03b6,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x03b7,
     0x03b8,
     0x03b9,
     0x03ba,
     0x03bb,
     0x03bc,
     0x00b4,
     0x007e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x03bd,
     0x03be,
     0x03bf,
     0x03c0,
     0x03c1,
     0x03c3,
     0x00a3,
     0x03ac,
     0x03ad,
     0x03ae,
     0x0390,
     0x03af,
     0x03cc,
     0x03cd,
     0x03b0,
     0x03ce,
     0x03c2,
     0x03c4,
     0x03c5,
     0x03c6,
     0x03c7,
     0x03c8,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x03c9,
     0x03ca,
     0x03cb,
     0x2018,
     0x2015,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x00b1,
     0x00bd,
     0xfffd,
     0x00b7,
     0x2019,
     0x00a6,
     0x005c,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00a7,
     0xfffd,
     0xfffd,
     0x00ab,
     0x00ac,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00a9,
     0xfffd,
     0xfffd,
     0x00bb,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xce\x91",
     "\xce\x92",
     "\xce\x93",
     "\xce\x94",
     "\xce\x95",
     "\xce\x96",
     "\xce\x97",
     "\xce\x98",
     "\xce\x99",
     "\x5b",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xce\x9a",
     "\xce\x9b",
     "\xce\x9c",
     "\xce\x9d",
     "\xce\x9e",
     "\xce\x9f",
     "\xce\xa0",
     "\xce\xa1",
     "\xce\xa3",
     "\x5d",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xce\xa4",
     "\xce\xa5",
     "\xce\xa6",
     "\xce\xa7",
     "\xce\xa8",
     "\xce\xa9",
     "\xce\xaa",
     "\xce\xab",
     "\xef\xbf\xbd",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xc2\xa8",
     "\xce\x86",
     "\xce\x88",
     "\xce\x89",
     "\xe2\x88\x87",
     "\xce\x8a",
     "\xce\x8c",
     "\xce\x8e",
     "\xce\x8f",
     "\x60",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xce\x85",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\xb3",
     "\xce\xb4",
     "\xce\xb5",
     "\xce\xb6",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xce\xb7",
     "\xce\xb8",
     "\xce\xb9",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xc2\xb4",
     "\x7e",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xce\xbd",
     "\xce\xbe",
     "\xce\xbf",
     "\xcf\x80",
     "\xcf\x81",
     "\xcf\x83",
     "\xc2\xa3",
     "\xce\xac",
     "\xce\xad",
     "\xce\xae",
     "\xce\x90",
     "\xce\xaf",
     "\xcf\x8c",
     "\xcf\x8d",
     "\xce\xb0",
     "\xcf\x8e",
     "\xcf\x82",
     "\xcf\x84",
     "\xcf\x85",
     "\xcf\x86",
     "\xcf\x87",
     "\xcf\x88",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xcf\x89",
     "\xcf\x8a",
     "\xcf\x8b",
     "\xe2\x80\x98",
     "\xe2\x80\x95",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xc2\xb1",
     "\xc2\xbd",
     "\xef\xbf\xbd",
     "\xc2\xb7",
     "\xe2\x80\x99",
     "\xc2\xa6",
     "\x5c",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc2\xa7",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xab",
     "\xc2\xac",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc2\xa9",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xbb",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x4a",
     0x0000005c => "\xe0",
     0x0000005d => "\x5a",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x79",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007d => "\xd0",
     0x0000007e => "\xa1",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a3 => "\xb0",
     0x000000a6 => "\xdf",
     0x000000a7 => "\xeb",
     0x000000a8 => "\x70",
     0x000000a9 => "\xfb",
     0x000000ab => "\xee",
     0x000000ac => "\xef",
     0x000000ad => "\xca",
     0x000000b0 => "\x90",
     0x000000b1 => "\xda",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xa0",
     0x000000b7 => "\xdd",
     0x000000bb => "\xfe",
     0x000000bd => "\xdb",
     0x00000385 => "\x80",
     0x00000386 => "\x71",
     0x00000388 => "\x72",
     0x00000389 => "\x73",
     0x0000038a => "\x75",
     0x0000038c => "\x76",
     0x0000038e => "\x77",
     0x0000038f => "\x78",
     0x00000390 => "\xb4",
     0x00000391 => "\x41",
     0x00000392 => "\x42",
     0x00000393 => "\x43",
     0x00000394 => "\x44",
     0x00000395 => "\x45",
     0x00000396 => "\x46",
     0x00000397 => "\x47",
     0x00000398 => "\x48",
     0x00000399 => "\x49",
     0x0000039a => "\x51",
     0x0000039b => "\x52",
     0x0000039c => "\x53",
     0x0000039d => "\x54",
     0x0000039e => "\x55",
     0x0000039f => "\x56",
     0x000003a0 => "\x57",
     0x000003a1 => "\x58",
     0x000003a3 => "\x59",
     0x000003a4 => "\x62",
     0x000003a5 => "\x63",
     0x000003a6 => "\x64",
     0x000003a7 => "\x65",
     0x000003a8 => "\x66",
     0x000003a9 => "\x67",
     0x000003aa => "\x68",
     0x000003ab => "\x69",
     0x000003ac => "\xb1",
     0x000003ad => "\xb2",
     0x000003ae => "\xb3",
     0x000003af => "\xb5",
     0x000003b0 => "\xb8",
     0x000003b1 => "\x8a",
     0x000003b2 => "\x8b",
     0x000003b3 => "\x8c",
     0x000003b4 => "\x8d",
     0x000003b5 => "\x8e",
     0x000003b6 => "\x8f",
     0x000003b7 => "\x9a",
     0x000003b8 => "\x9b",
     0x000003b9 => "\x9c",
     0x000003ba => "\x9d",
     0x000003bb => "\x9e",
     0x000003bc => "\x9f",
     0x000003bd => "\xaa",
     0x000003be => "\xab",
     0x000003bf => "\xac",
     0x000003c0 => "\xad",
     0x000003c1 => "\xae",
     0x000003c2 => "\xba",
     0x000003c3 => "\xaf",
     0x000003c4 => "\xbb",
     0x000003c5 => "\xbc",
     0x000003c6 => "\xbd",
     0x000003c7 => "\xbe",
     0x000003c8 => "\xbf",
     0x000003c9 => "\xcb",
     0x000003ca => "\xcc",
     0x000003cb => "\xcd",
     0x000003cc => "\xb6",
     0x000003cd => "\xb7",
     0x000003ce => "\xb9",
     0x00002015 => "\xcf",
     0x00002018 => "\xce",
     0x00002019 => "\xde",
     0x00002207 => "\x74",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM880.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM880;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0x0452,
     0x0453,
     0x0451,
     0xfffd,
     0x0455,
     0x0456,
     0x0457,
     0x0458,
     0x005b,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x0459,
     0x045a,
     0x045b,
     0x045c,
     0xfffd,
     0x045f,
     0x042a,
     0x2116,
     0x0402,
     0x005d,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x0403,
     0x0401,
     0xfffd,
     0x0405,
     0x0406,
     0x0407,
     0x0408,
     0x0409,
     0x00a6,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x040a,
     0x040b,
     0x040c,
     0xfffd,
     0xfffd,
     0x040f,
     0x044e,
     0x0430,
     0x0431,
     0xfffd,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0x0446,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x0434,
     0x0435,
     0x0444,
     0x0433,
     0x0445,
     0x0438,
     0x0439,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x044f,
     0xfffd,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0436,
     0x0432,
     0x044c,
     0x044b,
     0x0437,
     0x0448,
     0x044d,
     0x0449,
     0x0447,
     0x044a,
     0x042e,
     0x0410,
     0x0411,
     0x0426,
     0x0414,
     0x0415,
     0x0424,
     0x0413,
     0xfffd,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x0425,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0xfffd,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x041d,
     0x041e,
     0x041f,
     0x042f,
     0x0420,
     0x0421,
     0x005c,
     0x00a4,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x0422,
     0x0423,
     0x0416,
     0x0412,
     0x042c,
     0x042b,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x0417,
     0x0428,
     0x042d,
     0x0429,
     0x0427,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xd1\x92",
     "\xd1\x93",
     "\xd1\x91",
     "\xef\xbf\xbd",
     "\xd1\x95",
     "\xd1\x96",
     "\xd1\x97",
     "\xd1\x98",
     "\x5b",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xd1\x99",
     "\xd1\x9a",
     "\xd1\x9b",
     "\xd1\x9c",
     "\xef\xbf\xbd",
     "\xd1\x9f",
     "\xd0\xaa",
     "\xe2\x84\x96",
     "\xd0\x82",
     "\x5d",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xd0\x83",
     "\xd0\x81",
     "\xef\xbf\xbd",
     "\xd0\x85",
     "\xd0\x86",
     "\xd0\x87",
     "\xd0\x88",
     "\xd0\x89",
     "\xc2\xa6",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xd0\x8a",
     "\xd0\x8b",
     "\xd0\x8c",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd0\x8f",
     "\xd1\x8e",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xef\xbf\xbd",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xd1\x86",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd1\x84",
     "\xd0\xb3",
     "\xd1\x85",
     "\xd0\xb8",
     "\xd0\xb9",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x8f",
     "\xef\xbf\xbd",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd0\xb6",
     "\xd0\xb2",
     "\xd1\x8c",
     "\xd1\x8b",
     "\xd0\xb7",
     "\xd1\x88",
     "\xd1\x8d",
     "\xd1\x89",
     "\xd1\x87",
     "\xd1\x8a",
     "\xd0\xae",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\xa6",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\xa4",
     "\xd0\x93",
     "\xef\xbf\xbd",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xd0\xa5",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xef\xbf\xbd",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xaf",
     "\xd0\xa0",
     "\xd0\xa1",
     "\x5c",
     "\xc2\xa4",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\x96",
     "\xd0\x92",
     "\xd0\xac",
     "\xd0\xab",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xd0\x97",
     "\xd0\xa8",
     "\xd0\xad",
     "\xd0\xa9",
     "\xd0\xa7",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x4a",
     0x0000005c => "\xe0",
     0x0000005d => "\x5a",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a4 => "\xe1",
     0x000000a6 => "\x6a",
     0x00000401 => "\x63",
     0x00000402 => "\x59",
     0x00000403 => "\x62",
     0x00000405 => "\x65",
     0x00000406 => "\x66",
     0x00000407 => "\x67",
     0x00000408 => "\x68",
     0x00000409 => "\x69",
     0x0000040a => "\x70",
     0x0000040b => "\x71",
     0x0000040c => "\x72",
     0x0000040f => "\x75",
     0x00000410 => "\xb9",
     0x00000411 => "\xba",
     0x00000412 => "\xed",
     0x00000413 => "\xbf",
     0x00000414 => "\xbc",
     0x00000415 => "\xbd",
     0x00000416 => "\xec",
     0x00000417 => "\xfa",
     0x00000418 => "\xcb",
     0x00000419 => "\xcc",
     0x0000041a => "\xcd",
     0x0000041b => "\xce",
     0x0000041c => "\xcf",
     0x0000041d => "\xda",
     0x0000041e => "\xdb",
     0x0000041f => "\xdc",
     0x00000420 => "\xde",
     0x00000421 => "\xdf",
     0x00000422 => "\xea",
     0x00000423 => "\xeb",
     0x00000424 => "\xbe",
     0x00000425 => "\xca",
     0x00000426 => "\xbb",
     0x00000427 => "\xfe",
     0x00000428 => "\xfb",
     0x00000429 => "\xfd",
     0x0000042a => "\x57",
     0x0000042b => "\xef",
     0x0000042c => "\xee",
     0x0000042d => "\xfc",
     0x0000042e => "\xb8",
     0x0000042f => "\xdd",
     0x00000430 => "\x77",
     0x00000431 => "\x78",
     0x00000432 => "\xaf",
     0x00000433 => "\x8d",
     0x00000434 => "\x8a",
     0x00000435 => "\x8b",
     0x00000436 => "\xae",
     0x00000437 => "\xb2",
     0x00000438 => "\x8f",
     0x00000439 => "\x90",
     0x0000043a => "\x9a",
     0x0000043b => "\x9b",
     0x0000043c => "\x9c",
     0x0000043d => "\x9d",
     0x0000043e => "\x9e",
     0x0000043f => "\x9f",
     0x00000440 => "\xaa",
     0x00000441 => "\xab",
     0x00000442 => "\xac",
     0x00000443 => "\xad",
     0x00000444 => "\x8c",
     0x00000445 => "\x8e",
     0x00000446 => "\x80",
     0x00000447 => "\xb6",
     0x00000448 => "\xb3",
     0x00000449 => "\xb5",
     0x0000044a => "\xb7",
     0x0000044b => "\xb1",
     0x0000044c => "\xb0",
     0x0000044d => "\xb4",
     0x0000044e => "\x76",
     0x0000044f => "\xa0",
     0x00000451 => "\x44",
     0x00000452 => "\x42",
     0x00000453 => "\x43",
     0x00000455 => "\x46",
     0x00000456 => "\x47",
     0x00000457 => "\x48",
     0x00000458 => "\x49",
     0x00000459 => "\x51",
     0x0000045a => "\x52",
     0x0000045b => "\x53",
     0x0000045c => "\x54",
     0x0000045f => "\x56",
     0x00002116 => "\x58",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM891.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM891;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM903.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM903;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM904.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM904;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00a2,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00ac,
     0x00a6,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\xa2",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xac",
     "\xc2\xa6",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a2 => "\x80",
     0x000000a6 => "\xfe",
     0x000000ac => "\xfd",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM905.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM905;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0xfffd,
     0x00e2,
     0x00e4,
     0x00e0,
     0x00e1,
     0xfffd,
     0x010b,
     0x007b,
     0x00f1,
     0x00c7,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00e8,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00ec,
     0x00df,
     0x011e,
     0x0130,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0x00c2,
     0x00c4,
     0x00c0,
     0x00c1,
     0xfffd,
     0x010a,
     0x005b,
     0x00d1,
     0x015f,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0xfffd,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x0131,
     0x003a,
     0x00d6,
     0x015e,
     0x0027,
     0x003d,
     0x00dc,
     0x02d8,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x0127,
     0x0109,
     0x015d,
     0x016d,
     0xfffd,
     0x007c,
     0x00b0,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0125,
     0x011d,
     0x0135,
     0x02db,
     0xfffd,
     0x00a4,
     0x00b5,
     0x00f6,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x0126,
     0x0108,
     0x015c,
     0x016c,
     0xfffd,
     0x0040,
     0x00b7,
     0x00a3,
     0x017c,
     0x007d,
     0x017b,
     0x00a7,
     0x005d,
     0xfffd,
     0x00bd,
     0x0024,
     0x0124,
     0x011c,
     0x0134,
     0x00a8,
     0x00b4,
     0x00d7,
     0x00e7,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0x00f4,
     0x007e,
     0x00f2,
     0x00f3,
     0x0121,
     0x011f,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0060,
     0x00fb,
     0x005c,
     0x00f9,
     0x00fa,
     0xfffd,
     0x00fc,
     0x00f7,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00b2,
     0x00d4,
     0x0023,
     0x00d2,
     0x00d3,
     0x0120,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x00b3,
     0x00db,
     0x0022,
     0x00d9,
     0x00da,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xef\xbf\xbd",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xef\xbf\xbd",
     "\xc4\x8b",
     "\x7b",
     "\xc3\xb1",
     "\xc3\x87",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xa8",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xac",
     "\xc3\x9f",
     "\xc4\x9e",
     "\xc4\xb0",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xc3\x82",
     "\xc3\x84",
     "\xc3\x80",
     "\xc3\x81",
     "\xef\xbf\xbd",
     "\xc4\x8a",
     "\x5b",
     "\xc3\x91",
     "\xc5\x9f",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xef\xbf\xbd",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc4\xb1",
     "\x3a",
     "\xc3\x96",
     "\xc5\x9e",
     "\x27",
     "\x3d",
     "\xc3\x9c",
     "\xcb\x98",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xc4\xa7",
     "\xc4\x89",
     "\xc5\x9d",
     "\xc5\xad",
     "\xef\xbf\xbd",
     "\x7c",
     "\xc2\xb0",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xc4\xa5",
     "\xc4\x9d",
     "\xc4\xb5",
     "\xcb\x9b",
     "\xef\xbf\xbd",
     "\xc2\xa4",
     "\xc2\xb5",
     "\xc3\xb6",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc4\xa6",
     "\xc4\x88",
     "\xc5\x9c",
     "\xc5\xac",
     "\xef\xbf\xbd",
     "\x40",
     "\xc2\xb7",
     "\xc2\xa3",
     "\xc5\xbc",
     "\x7d",
     "\xc5\xbb",
     "\xc2\xa7",
     "\x5d",
     "\xef\xbf\xbd",
     "\xc2\xbd",
     "\x24",
     "\xc4\xa4",
     "\xc4\x9c",
     "\xc4\xb4",
     "\xc2\xa8",
     "\xc2\xb4",
     "\xc3\x97",
     "\xc3\xa7",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xc3\xb4",
     "\x7e",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc4\xa1",
     "\xc4\x9f",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x60",
     "\xc3\xbb",
     "\x5c",
     "\xc3\xb9",
     "\xc3\xba",
     "\xef\xbf\xbd",
     "\xc3\xbc",
     "\xc3\xb7",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc2\xb2",
     "\xc3\x94",
     "\x23",
     "\xc3\x92",
     "\xc3\x93",
     "\xc4\xa0",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xc2\xb3",
     "\xc3\x9b",
     "\x22",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\xfc",
     0x00000023 => "\xec",
     0x00000024 => "\xb9",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\xaf",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x68",
     0x0000005c => "\xdc",
     0x0000005d => "\xb6",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\xda",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\x48",
     0x0000007c => "\x8f",
     0x0000007d => "\xb3",
     0x0000007e => "\xcc",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a3 => "\xb1",
     0x000000a4 => "\x9f",
     0x000000a7 => "\xb5",
     0x000000a8 => "\xbd",
     0x000000ad => "\xca",
     0x000000b0 => "\x90",
     0x000000b2 => "\xea",
     0x000000b3 => "\xfa",
     0x000000b4 => "\xbe",
     0x000000b5 => "\xa0",
     0x000000b7 => "\xb0",
     0x000000bd => "\xb8",
     0x000000c0 => "\x64",
     0x000000c1 => "\x65",
     0x000000c2 => "\x62",
     0x000000c4 => "\x63",
     0x000000c7 => "\x4a",
     0x000000c8 => "\x74",
     0x000000c9 => "\x71",
     0x000000ca => "\x72",
     0x000000cb => "\x73",
     0x000000cc => "\x78",
     0x000000cd => "\x75",
     0x000000ce => "\x76",
     0x000000cf => "\x77",
     0x000000d1 => "\x69",
     0x000000d2 => "\xed",
     0x000000d3 => "\xee",
     0x000000d4 => "\xeb",
     0x000000d6 => "\x7b",
     0x000000d7 => "\xbf",
     0x000000d9 => "\xfd",
     0x000000da => "\xfe",
     0x000000db => "\xfb",
     0x000000dc => "\x7f",
     0x000000df => "\x59",
     0x000000e0 => "\x44",
     0x000000e1 => "\x45",
     0x000000e2 => "\x42",
     0x000000e4 => "\x43",
     0x000000e7 => "\xc0",
     0x000000e8 => "\x54",
     0x000000e9 => "\x51",
     0x000000ea => "\x52",
     0x000000eb => "\x53",
     0x000000ec => "\x58",
     0x000000ed => "\x55",
     0x000000ee => "\x56",
     0x000000ef => "\x57",
     0x000000f1 => "\x49",
     0x000000f2 => "\xcd",
     0x000000f3 => "\xce",
     0x000000f4 => "\xcb",
     0x000000f6 => "\xa1",
     0x000000f7 => "\xe1",
     0x000000f9 => "\xdd",
     0x000000fa => "\xde",
     0x000000fb => "\xdb",
     0x000000fc => "\xe0",
     0x00000108 => "\xab",
     0x00000109 => "\x8b",
     0x0000010a => "\x67",
     0x0000010b => "\x47",
     0x0000011c => "\xbb",
     0x0000011d => "\x9b",
     0x0000011e => "\x5a",
     0x0000011f => "\xd0",
     0x00000120 => "\xef",
     0x00000121 => "\xcf",
     0x00000124 => "\xba",
     0x00000125 => "\x9a",
     0x00000126 => "\xaa",
     0x00000127 => "\x8a",
     0x00000130 => "\x5b",
     0x00000131 => "\x79",
     0x00000134 => "\xbc",
     0x00000135 => "\x9c",
     0x0000015c => "\xac",
     0x0000015d => "\x8c",
     0x0000015e => "\x7c",
     0x0000015f => "\x6a",
     0x0000016c => "\xad",
     0x0000016d => "\x8d",
     0x0000017b => "\xb4",
     0x0000017c => "\xb2",
     0x000002d8 => "\x80",
     0x000002db => "\x9d",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IBM918.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IBM918;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x009c,
     0x0009,
     0x0086,
     0x007f,
     0x0097,
     0x008d,
     0x008e,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x009d,
     0x0085,
     0x0008,
     0x0087,
     0x0018,
     0x0019,
     0x0092,
     0x008f,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x000a,
     0x0017,
     0x001b,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x0005,
     0x0006,
     0x0007,
     0x0090,
     0x0091,
     0x0016,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0004,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x0014,
     0x0015,
     0x009e,
     0x001a,
     0x0020,
     0x00a0,
     0x060c,
     0x061b,
     0x061f,
     0x0623,
     0x0627,
     0xfe8e,
     0xfffd,
     0x0628,
     0x005b,
     0x002e,
     0x003c,
     0x0028,
     0x002b,
     0x0021,
     0x0026,
     0xfe91,
     0x067e,
     0xfffd,
     0x0629,
     0x062a,
     0xfe97,
     0xfffd,
     0xfffd,
     0x062b,
     0x005d,
     0x0024,
     0x002a,
     0x0029,
     0x003b,
     0x005e,
     0x002d,
     0x002f,
     0xfe9b,
     0x062c,
     0xfe9f,
     0xfffd,
     0xfffd,
     0x062d,
     0xfea3,
     0x062e,
     0x0060,
     0x002c,
     0x0025,
     0x005f,
     0x003e,
     0x003f,
     0x0660,
     0x0661,
     0x0662,
     0x0663,
     0x0664,
     0x0665,
     0x0666,
     0x0667,
     0x0668,
     0x0669,
     0x003a,
     0x0023,
     0x0040,
     0x0027,
     0x003d,
     0x0022,
     0xfea7,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x062f,
     0xfffd,
     0x0630,
     0x0631,
     0xfffd,
     0x0632,
     0xfffd,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0633,
     0xfeb3,
     0x0634,
     0xfeb7,
     0x0635,
     0xfebb,
     0x0636,
     0x007e,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfebf,
     0x0637,
     0x0638,
     0x0639,
     0xfeca,
     0xfecb,
     0xfecc,
     0x063a,
     0xfece,
     0xfecf,
     0xfed0,
     0x0641,
     0xfed3,
     0x0642,
     0xfed7,
     0x0643,
     0xfedb,
     0x007c,
     0xfffd,
     0xfffd,
     0x0644,
     0xfede,
     0x007b,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x00ad,
     0xfffd,
     0x0645,
     0xfee3,
     0xfffd,
     0x0646,
     0x007d,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0xfee7,
     0xfffd,
     0x0648,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005c,
     0xfffd,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x0621,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0651,
     0xfe7d,
     0x009f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\xc2\x9c",
     "\x09",
     "\xc2\x86",
     "\x7f",
     "\xc2\x97",
     "\xc2\x8d",
     "\xc2\x8e",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xc2\x9d",
     "\xc2\x85",
     "\x08",
     "\xc2\x87",
     "\x18",
     "\x19",
     "\xc2\x92",
     "\xc2\x8f",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\x0a",
     "\x17",
     "\x1b",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\x05",
     "\x06",
     "\x07",
     "\xc2\x90",
     "\xc2\x91",
     "\x16",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\x04",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\x14",
     "\x15",
     "\xc2\x9e",
     "\x1a",
     "\x20",
     "\xc2\xa0",
     "\xd8\x8c",
     "\xd8\x9b",
     "\xd8\x9f",
     "\xd8\xa3",
     "\xd8\xa7",
     "\xef\xba\x8e",
     "\xef\xbf\xbd",
     "\xd8\xa8",
     "\x5b",
     "\x2e",
     "\x3c",
     "\x28",
     "\x2b",
     "\x21",
     "\x26",
     "\xef\xba\x91",
     "\xd9\xbe",
     "\xef\xbf\xbd",
     "\xd8\xa9",
     "\xd8\xaa",
     "\xef\xba\x97",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd8\xab",
     "\x5d",
     "\x24",
     "\x2a",
     "\x29",
     "\x3b",
     "\x5e",
     "\x2d",
     "\x2f",
     "\xef\xba\x9b",
     "\xd8\xac",
     "\xef\xba\x9f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd8\xad",
     "\xef\xba\xa3",
     "\xd8\xae",
     "\x60",
     "\x2c",
     "\x25",
     "\x5f",
     "\x3e",
     "\x3f",
     "\xd9\xa0",
     "\xd9\xa1",
     "\xd9\xa2",
     "\xd9\xa3",
     "\xd9\xa4",
     "\xd9\xa5",
     "\xd9\xa6",
     "\xd9\xa7",
     "\xd9\xa8",
     "\xd9\xa9",
     "\x3a",
     "\x23",
     "\x40",
     "\x27",
     "\x3d",
     "\x22",
     "\xef\xba\xa7",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\xd8\xaf",
     "\xef\xbf\xbd",
     "\xd8\xb0",
     "\xd8\xb1",
     "\xef\xbf\xbd",
     "\xd8\xb2",
     "\xef\xbf\xbd",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\xd8\xb3",
     "\xef\xba\xb3",
     "\xd8\xb4",
     "\xef\xba\xb7",
     "\xd8\xb5",
     "\xef\xba\xbb",
     "\xd8\xb6",
     "\x7e",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xba\xbf",
     "\xd8\xb7",
     "\xd8\xb8",
     "\xd8\xb9",
     "\xef\xbb\x8a",
     "\xef\xbb\x8b",
     "\xef\xbb\x8c",
     "\xd8\xba",
     "\xef\xbb\x8e",
     "\xef\xbb\x8f",
     "\xef\xbb\x90",
     "\xd9\x81",
     "\xef\xbb\x93",
     "\xd9\x82",
     "\xef\xbb\x97",
     "\xd9\x83",
     "\xef\xbb\x9b",
     "\x7c",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd9\x84",
     "\xef\xbb\x9e",
     "\x7b",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\xc2\xad",
     "\xef\xbf\xbd",
     "\xd9\x85",
     "\xef\xbb\xa3",
     "\xef\xbf\xbd",
     "\xd9\x86",
     "\x7d",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\xef\xbb\xa7",
     "\xef\xbf\xbd",
     "\xd9\x88",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5c",
     "\xef\xbf\xbd",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xd8\xa1",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd9\x91",
     "\xef\xb9\xbd",
     "\xc2\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x37",
     0x00000005 => "\x2d",
     0x00000006 => "\x2e",
     0x00000007 => "\x2f",
     0x00000008 => "\x16",
     0x00000009 => "\x05",
     0x0000000a => "\x25",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x3c",
     0x00000015 => "\x3d",
     0x00000016 => "\x32",
     0x00000017 => "\x26",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x3f",
     0x0000001b => "\x27",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x40",
     0x00000021 => "\x4f",
     0x00000022 => "\x7f",
     0x00000023 => "\x7b",
     0x00000024 => "\x5b",
     0x00000025 => "\x6c",
     0x00000026 => "\x50",
     0x00000027 => "\x7d",
     0x00000028 => "\x4d",
     0x00000029 => "\x5d",
     0x0000002a => "\x5c",
     0x0000002b => "\x4e",
     0x0000002c => "\x6b",
     0x0000002d => "\x60",
     0x0000002e => "\x4b",
     0x0000002f => "\x61",
     0x00000030 => "\xf0",
     0x00000031 => "\xf1",
     0x00000032 => "\xf2",
     0x00000033 => "\xf3",
     0x00000034 => "\xf4",
     0x00000035 => "\xf5",
     0x00000036 => "\xf6",
     0x00000037 => "\xf7",
     0x00000038 => "\xf8",
     0x00000039 => "\xf9",
     0x0000003a => "\x7a",
     0x0000003b => "\x5e",
     0x0000003c => "\x4c",
     0x0000003d => "\x7e",
     0x0000003e => "\x6e",
     0x0000003f => "\x6f",
     0x00000040 => "\x7c",
     0x00000041 => "\xc1",
     0x00000042 => "\xc2",
     0x00000043 => "\xc3",
     0x00000044 => "\xc4",
     0x00000045 => "\xc5",
     0x00000046 => "\xc6",
     0x00000047 => "\xc7",
     0x00000048 => "\xc8",
     0x00000049 => "\xc9",
     0x0000004a => "\xd1",
     0x0000004b => "\xd2",
     0x0000004c => "\xd3",
     0x0000004d => "\xd4",
     0x0000004e => "\xd5",
     0x0000004f => "\xd6",
     0x00000050 => "\xd7",
     0x00000051 => "\xd8",
     0x00000052 => "\xd9",
     0x00000053 => "\xe2",
     0x00000054 => "\xe3",
     0x00000055 => "\xe4",
     0x00000056 => "\xe5",
     0x00000057 => "\xe6",
     0x00000058 => "\xe7",
     0x00000059 => "\xe8",
     0x0000005a => "\xe9",
     0x0000005b => "\x4a",
     0x0000005c => "\xe0",
     0x0000005d => "\x5a",
     0x0000005e => "\x5f",
     0x0000005f => "\x6d",
     0x00000060 => "\x6a",
     0x00000061 => "\x81",
     0x00000062 => "\x82",
     0x00000063 => "\x83",
     0x00000064 => "\x84",
     0x00000065 => "\x85",
     0x00000066 => "\x86",
     0x00000067 => "\x87",
     0x00000068 => "\x88",
     0x00000069 => "\x89",
     0x0000006a => "\x91",
     0x0000006b => "\x92",
     0x0000006c => "\x93",
     0x0000006d => "\x94",
     0x0000006e => "\x95",
     0x0000006f => "\x96",
     0x00000070 => "\x97",
     0x00000071 => "\x98",
     0x00000072 => "\x99",
     0x00000073 => "\xa2",
     0x00000074 => "\xa3",
     0x00000075 => "\xa4",
     0x00000076 => "\xa5",
     0x00000077 => "\xa6",
     0x00000078 => "\xa7",
     0x00000079 => "\xa8",
     0x0000007a => "\xa9",
     0x0000007b => "\xc0",
     0x0000007c => "\xbb",
     0x0000007d => "\xd0",
     0x0000007e => "\xa1",
     0x0000007f => "\x07",
     0x00000080 => "\x20",
     0x00000081 => "\x21",
     0x00000082 => "\x22",
     0x00000083 => "\x23",
     0x00000084 => "\x24",
     0x00000085 => "\x15",
     0x00000086 => "\x06",
     0x00000087 => "\x17",
     0x00000088 => "\x28",
     0x00000089 => "\x29",
     0x0000008a => "\x2a",
     0x0000008b => "\x2b",
     0x0000008c => "\x2c",
     0x0000008d => "\x09",
     0x0000008e => "\x0a",
     0x0000008f => "\x1b",
     0x00000090 => "\x30",
     0x00000091 => "\x31",
     0x00000092 => "\x1a",
     0x00000093 => "\x33",
     0x00000094 => "\x34",
     0x00000095 => "\x35",
     0x00000096 => "\x36",
     0x00000097 => "\x08",
     0x00000098 => "\x38",
     0x00000099 => "\x39",
     0x0000009a => "\x3a",
     0x0000009b => "\x3b",
     0x0000009c => "\x04",
     0x0000009d => "\x14",
     0x0000009e => "\x3e",
     0x0000009f => "\xff",
     0x000000a0 => "\x41",
     0x000000ad => "\xca",
     0x0000060c => "\x42",
     0x0000061b => "\x43",
     0x0000061f => "\x44",
     0x00000621 => "\xea",
     0x00000623 => "\x45",
     0x00000627 => "\x46",
     0x00000628 => "\x49",
     0x00000629 => "\x54",
     0x0000062a => "\x55",
     0x0000062b => "\x59",
     0x0000062c => "\x63",
     0x0000062d => "\x67",
     0x0000062e => "\x69",
     0x0000062f => "\x8a",
     0x00000630 => "\x8c",
     0x00000631 => "\x8d",
     0x00000632 => "\x8f",
     0x00000633 => "\x9a",
     0x00000634 => "\x9c",
     0x00000635 => "\x9e",
     0x00000636 => "\xa0",
     0x00000637 => "\xab",
     0x00000638 => "\xac",
     0x00000639 => "\xad",
     0x0000063a => "\xb1",
     0x00000641 => "\xb5",
     0x00000642 => "\xb7",
     0x00000643 => "\xb9",
     0x00000644 => "\xbe",
     0x00000645 => "\xcc",
     0x00000646 => "\xcf",
     0x00000648 => "\xdc",
     0x00000651 => "\xfd",
     0x00000660 => "\x70",
     0x00000661 => "\x71",
     0x00000662 => "\x72",
     0x00000663 => "\x73",
     0x00000664 => "\x74",
     0x00000665 => "\x75",
     0x00000666 => "\x76",
     0x00000667 => "\x77",
     0x00000668 => "\x78",
     0x00000669 => "\x79",
     0x0000067e => "\x52",
     0x0000fe7d => "\xfe",
     0x0000fe8e => "\x47",
     0x0000fe91 => "\x51",
     0x0000fe97 => "\x56",
     0x0000fe9b => "\x62",
     0x0000fe9f => "\x64",
     0x0000fea3 => "\x68",
     0x0000fea7 => "\x80",
     0x0000feb3 => "\x9b",
     0x0000feb7 => "\x9d",
     0x0000febb => "\x9f",
     0x0000febf => "\xaa",
     0x0000feca => "\xae",
     0x0000fecb => "\xaf",
     0x0000fecc => "\xb0",
     0x0000fece => "\xb2",
     0x0000fecf => "\xb3",
     0x0000fed0 => "\xb4",
     0x0000fed3 => "\xb6",
     0x0000fed7 => "\xb8",
     0x0000fedb => "\xba",
     0x0000fede => "\xbf",
     0x0000fee3 => "\xcd",
     0x0000fee7 => "\xda",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x6f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/IEC_P27_1.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::IEC_P27_1;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x02c7,
     0x2261,
     0x2227,
     0x2228,
     0x2229,
     0x222a,
     0x2282,
     0x2283,
     0x21d0,
     0x21d2,
     0x2234,
     0x2235,
     0x2208,
     0x220b,
     0x2286,
     0x2287,
     0x222b,
     0x222e,
     0x221e,
     0x2207,
     0x2202,
     0x223c,
     0x2248,
     0x2243,
     0x2245,
     0x2264,
     0x2260,
     0x2265,
     0x2194,
     0x00ac,
     0x2200,
     0x2203,
     0x05d0,
     0x25a1,
     0x2225,
     0x0393,
     0x0394,
     0x22a5,
     0x2220,
     0x221f,
     0x0398,
     0x2329,
     0x232a,
     0x039b,
     0x2032,
     0x2033,
     0x039e,
     0x2213,
     0x03a0,
     0x00b2,
     0x03a3,
     0x00d7,
     0x00b3,
     0x03a5,
     0x03a6,
     0x00b7,
     0x03a8,
     0x03a9,
     0x2205,
     0x21c0,
     0x221a,
     0x0192,
     0x221d,
     0x00b1,
     0x00b0,
     0x03b1,
     0x03b2,
     0x03b3,
     0x03b4,
     0x03b5,
     0x03b6,
     0x03b7,
     0x03b8,
     0x03b9,
     0x03ba,
     0x03bb,
     0x03bc,
     0x03bd,
     0x03be,
     0x2030,
     0x03c0,
     0x03c1,
     0x03c3,
     0x00f7,
     0x03c4,
     0x03c5,
     0x03c6,
     0x03c7,
     0x03c8,
     0x03c9,
     0x2020,
     0x2190,
     0x2191,
     0x2192,
     0x2193,
     0x203e,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xcb\x87",
     "\xe2\x89\xa1",
     "\xe2\x88\xa7",
     "\xe2\x88\xa8",
     "\xe2\x88\xa9",
     "\xe2\x88\xaa",
     "\xe2\x8a\x82",
     "\xe2\x8a\x83",
     "\xe2\x87\x90",
     "\xe2\x87\x92",
     "\xe2\x88\xb4",
     "\xe2\x88\xb5",
     "\xe2\x88\x88",
     "\xe2\x88\x8b",
     "\xe2\x8a\x86",
     "\xe2\x8a\x87",
     "\xe2\x88\xab",
     "\xe2\x88\xae",
     "\xe2\x88\x9e",
     "\xe2\x88\x87",
     "\xe2\x88\x82",
     "\xe2\x88\xbc",
     "\xe2\x89\x88",
     "\xe2\x89\x83",
     "\xe2\x89\x85",
     "\xe2\x89\xa4",
     "\xe2\x89\xa0",
     "\xe2\x89\xa5",
     "\xe2\x86\x94",
     "\xc2\xac",
     "\xe2\x88\x80",
     "\xe2\x88\x83",
     "\xd7\x90",
     "\xe2\x96\xa1",
     "\xe2\x88\xa5",
     "\xce\x93",
     "\xce\x94",
     "\xe2\x8a\xa5",
     "\xe2\x88\xa0",
     "\xe2\x88\x9f",
     "\xce\x98",
     "\xe2\x8c\xa9",
     "\xe2\x8c\xaa",
     "\xce\x9b",
     "\xe2\x80\xb2",
     "\xe2\x80\xb3",
     "\xce\x9e",
     "\xe2\x88\x93",
     "\xce\xa0",
     "\xc2\xb2",
     "\xce\xa3",
     "\xc3\x97",
     "\xc2\xb3",
     "\xce\xa5",
     "\xce\xa6",
     "\xc2\xb7",
     "\xce\xa8",
     "\xce\xa9",
     "\xe2\x88\x85",
     "\xe2\x87\x80",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x88\x9d",
     "\xc2\xb1",
     "\xc2\xb0",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\xb3",
     "\xce\xb4",
     "\xce\xb5",
     "\xce\xb6",
     "\xce\xb7",
     "\xce\xb8",
     "\xce\xb9",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xce\xbd",
     "\xce\xbe",
     "\xe2\x80\xb0",
     "\xcf\x80",
     "\xcf\x81",
     "\xcf\x83",
     "\xc3\xb7",
     "\xcf\x84",
     "\xcf\x85",
     "\xcf\x86",
     "\xcf\x87",
     "\xcf\x88",
     "\xcf\x89",
     "\xe2\x80\xa0",
     "\xe2\x86\x90",
     "\xe2\x86\x91",
     "\xe2\x86\x92",
     "\xe2\x86\x93",
     "\xe2\x80\xbe",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000ac => "\xbd",
     0x000000b0 => "\xe0",
     0x000000b1 => "\xdf",
     0x000000b2 => "\xd1",
     0x000000b3 => "\xd4",
     0x000000b7 => "\xd7",
     0x000000d7 => "\xd3",
     0x000000f7 => "\xf3",
     0x00000192 => "\xdd",
     0x000002c7 => "\xa0",
     0x00000393 => "\xc3",
     0x00000394 => "\xc4",
     0x00000398 => "\xc8",
     0x0000039b => "\xcb",
     0x0000039e => "\xce",
     0x000003a0 => "\xd0",
     0x000003a3 => "\xd2",
     0x000003a5 => "\xd5",
     0x000003a6 => "\xd6",
     0x000003a8 => "\xd8",
     0x000003a9 => "\xd9",
     0x000003b1 => "\xe1",
     0x000003b2 => "\xe2",
     0x000003b3 => "\xe3",
     0x000003b4 => "\xe4",
     0x000003b5 => "\xe5",
     0x000003b6 => "\xe6",
     0x000003b7 => "\xe7",
     0x000003b8 => "\xe8",
     0x000003b9 => "\xe9",
     0x000003ba => "\xea",
     0x000003bb => "\xeb",
     0x000003bc => "\xec",
     0x000003bd => "\xed",
     0x000003be => "\xee",
     0x000003c0 => "\xf0",
     0x000003c1 => "\xf1",
     0x000003c3 => "\xf2",
     0x000003c4 => "\xf4",
     0x000003c5 => "\xf5",
     0x000003c6 => "\xf6",
     0x000003c7 => "\xf7",
     0x000003c8 => "\xf8",
     0x000003c9 => "\xf9",
     0x000005d0 => "\xc0",
     0x00002020 => "\xfa",
     0x00002030 => "\xef",
     0x00002032 => "\xcc",
     0x00002033 => "\xcd",
     0x0000203e => "\xff",
     0x00002190 => "\xfb",
     0x00002191 => "\xfc",
     0x00002192 => "\xfd",
     0x00002193 => "\xfe",
     0x00002194 => "\xbc",
     0x000021c0 => "\xdb",
     0x000021d0 => "\xa8",
     0x000021d2 => "\xa9",
     0x00002200 => "\xbe",
     0x00002202 => "\xb4",
     0x00002203 => "\xbf",
     0x00002205 => "\xda",
     0x00002207 => "\xb3",
     0x00002208 => "\xac",
     0x0000220b => "\xad",
     0x00002213 => "\xcf",
     0x0000221a => "\xdc",
     0x0000221d => "\xde",
     0x0000221e => "\xb2",
     0x0000221f => "\xc7",
     0x00002220 => "\xc6",
     0x00002225 => "\xc2",
     0x00002227 => "\xa2",
     0x00002228 => "\xa3",
     0x00002229 => "\xa4",
     0x0000222a => "\xa5",
     0x0000222b => "\xb0",
     0x0000222e => "\xb1",
     0x00002234 => "\xaa",
     0x00002235 => "\xab",
     0x0000223c => "\xb5",
     0x00002243 => "\xb7",
     0x00002245 => "\xb8",
     0x00002248 => "\xb6",
     0x00002260 => "\xba",
     0x00002261 => "\xa1",
     0x00002264 => "\xb9",
     0x00002265 => "\xbb",
     0x00002282 => "\xa6",
     0x00002283 => "\xa7",
     0x00002286 => "\xae",
     0x00002287 => "\xaf",
     0x000022a5 => "\xc5",
     0x00002329 => "\xc9",
     0x0000232a => "\xca",
     0x000025a1 => "\xc1",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/INIS.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::INIS;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0024,
     0x0025,
     0xfffd,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0xfffd,
     0xfffd,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0xfffd,
     0x005d,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0xfffd,
     0x007c,
     0xfffd,
     0xfffd,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x24",
     "\x25",
     "\xef\xbf\xbd",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\xef\xbf\xbd",
     "\x5d",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xef\xbf\xbd",
     "\x7c",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005d => "\x5d",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007c => "\x7c",
     0x0000007f => "\x7f",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/INIS_8.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::INIS_8;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x03b1,
     0x03b2,
     0x03b3,
     0x03b4,
     0x039e,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x2192,
     0x222b,
     0x2070,
     0x00b9,
     0x00b2,
     0x00b3,
     0x2074,
     0x2075,
     0x2076,
     0x2077,
     0x2078,
     0x2079,
     0x207a,
     0x207b,
     0x30eb,
     0x0394,
     0x039b,
     0x03a9,
     0x2080,
     0x2081,
     0x2082,
     0x2083,
     0x2084,
     0x2085,
     0x2086,
     0x2087,
     0x2088,
     0x2089,
     0x03a3,
     0x03bc,
     0x03bd,
     0x03c9,
     0x03c0,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\xb3",
     "\xce\xb4",
     "\xce\x9e",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x86\x92",
     "\xe2\x88\xab",
     "\xe2\x81\xb0",
     "\xc2\xb9",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xe2\x81\xb4",
     "\xe2\x81\xb5",
     "\xe2\x81\xb6",
     "\xe2\x81\xb7",
     "\xe2\x81\xb8",
     "\xe2\x81\xb9",
     "\xe2\x81\xba",
     "\xe2\x81\xbb",
     "\xe3\x83\xab",
     "\xce\x94",
     "\xce\x9b",
     "\xce\xa9",
     "\xe2\x82\x80",
     "\xe2\x82\x81",
     "\xe2\x82\x82",
     "\xe2\x82\x83",
     "\xe2\x82\x84",
     "\xe2\x82\x85",
     "\xe2\x82\x86",
     "\xe2\x82\x87",
     "\xe2\x82\x88",
     "\xe2\x82\x89",
     "\xce\xa3",
     "\xce\xbc",
     "\xce\xbd",
     "\xcf\x89",
     "\xcf\x80",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x0000007f => "\x7f",
     0x000000b2 => "\x62",
     0x000000b3 => "\x63",
     0x000000b9 => "\x61",
     0x00000394 => "\x6d",
     0x0000039b => "\x6e",
     0x0000039e => "\x3e",
     0x000003a3 => "\x7a",
     0x000003a9 => "\x6f",
     0x000003b1 => "\x3a",
     0x000003b2 => "\x3b",
     0x000003b3 => "\x3c",
     0x000003b4 => "\x3d",
     0x000003bc => "\x7b",
     0x000003bd => "\x7c",
     0x000003c0 => "\x7e",
     0x000003c9 => "\x7d",
     0x00002070 => "\x60",
     0x00002074 => "\x64",
     0x00002075 => "\x65",
     0x00002076 => "\x66",
     0x00002077 => "\x67",
     0x00002078 => "\x68",
     0x00002079 => "\x69",
     0x0000207a => "\x6a",
     0x0000207b => "\x6b",
     0x00002080 => "\x70",
     0x00002081 => "\x71",
     0x00002082 => "\x72",
     0x00002083 => "\x73",
     0x00002084 => "\x74",
     0x00002085 => "\x75",
     0x00002086 => "\x76",
     0x00002087 => "\x77",
     0x00002088 => "\x78",
     0x00002089 => "\x79",
     0x00002192 => "\x5e",
     0x0000222b => "\x5f",
     0x000030eb => "\x6c",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/INIS_CYRILLIC.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::INIS_CYRILLIC;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x221a,
     0xfffd,
     0x2192,
     0x222b,
     0x03b1,
     0x03b2,
     0x03b3,
     0x03b4,
     0x03a3,
     0x03bc,
     0x03bd,
     0x03c9,
     0x03c0,
     0x039e,
     0x0394,
     0x039b,
     0x03a9,
     0x042a,
     0x207b,
     0x207a,
     0x044e,
     0x0430,
     0x0431,
     0x0446,
     0x0434,
     0x0435,
     0x0444,
     0x0433,
     0x0445,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x044f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0436,
     0x0432,
     0x044c,
     0x044b,
     0x0437,
     0x0448,
     0x044d,
     0x0449,
     0x0447,
     0x044a,
     0x042e,
     0x0410,
     0x0411,
     0x0426,
     0x0414,
     0x0415,
     0x0424,
     0x0413,
     0x0425,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x042f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0416,
     0x0412,
     0x042c,
     0x042b,
     0x0417,
     0x0428,
     0x042d,
     0x0429,
     0x0427,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x88\x9a",
     "\xef\xbf\xbd",
     "\xe2\x86\x92",
     "\xe2\x88\xab",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\xb3",
     "\xce\xb4",
     "\xce\xa3",
     "\xce\xbc",
     "\xce\xbd",
     "\xcf\x89",
     "\xcf\x80",
     "\xce\x9e",
     "\xce\x94",
     "\xce\x9b",
     "\xce\xa9",
     "\xd0\xaa",
     "\xe2\x81\xbb",
     "\xe2\x81\xba",
     "\xd1\x8e",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd1\x86",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd1\x84",
     "\xd0\xb3",
     "\xd1\x85",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x8f",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd0\xb6",
     "\xd0\xb2",
     "\xd1\x8c",
     "\xd1\x8b",
     "\xd0\xb7",
     "\xd1\x88",
     "\xd1\x8d",
     "\xd1\x89",
     "\xd1\x87",
     "\xd1\x8a",
     "\xd0\xae",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\xa6",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\xa4",
     "\xd0\x93",
     "\xd0\xa5",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xaf",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\x96",
     "\xd0\x92",
     "\xd0\xac",
     "\xd0\xab",
     "\xd0\x97",
     "\xd0\xa8",
     "\xd0\xad",
     "\xd0\xa9",
     "\xd0\xa7",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x0000007f => "\x7f",
     0x00000394 => "\x3a",
     0x0000039b => "\x3b",
     0x0000039e => "\x39",
     0x000003a3 => "\x34",
     0x000003a9 => "\x3c",
     0x000003b1 => "\x30",
     0x000003b2 => "\x31",
     0x000003b3 => "\x32",
     0x000003b4 => "\x33",
     0x000003bc => "\x35",
     0x000003bd => "\x36",
     0x000003c0 => "\x38",
     0x000003c9 => "\x37",
     0x00000410 => "\x61",
     0x00000411 => "\x62",
     0x00000412 => "\x77",
     0x00000413 => "\x67",
     0x00000414 => "\x64",
     0x00000415 => "\x65",
     0x00000416 => "\x76",
     0x00000417 => "\x7a",
     0x00000418 => "\x69",
     0x00000419 => "\x6a",
     0x0000041a => "\x6b",
     0x0000041b => "\x6c",
     0x0000041c => "\x6d",
     0x0000041d => "\x6e",
     0x0000041e => "\x6f",
     0x0000041f => "\x70",
     0x00000420 => "\x72",
     0x00000421 => "\x73",
     0x00000422 => "\x74",
     0x00000423 => "\x75",
     0x00000424 => "\x66",
     0x00000425 => "\x68",
     0x00000426 => "\x63",
     0x00000427 => "\x7e",
     0x00000428 => "\x7b",
     0x00000429 => "\x7d",
     0x0000042a => "\x3d",
     0x0000042b => "\x79",
     0x0000042c => "\x78",
     0x0000042d => "\x7c",
     0x0000042e => "\x60",
     0x0000042f => "\x71",
     0x00000430 => "\x41",
     0x00000431 => "\x42",
     0x00000432 => "\x57",
     0x00000433 => "\x47",
     0x00000434 => "\x44",
     0x00000435 => "\x45",
     0x00000436 => "\x56",
     0x00000437 => "\x5a",
     0x00000438 => "\x49",
     0x00000439 => "\x4a",
     0x0000043a => "\x4b",
     0x0000043b => "\x4c",
     0x0000043c => "\x4d",
     0x0000043d => "\x4e",
     0x0000043e => "\x4f",
     0x0000043f => "\x50",
     0x00000440 => "\x52",
     0x00000441 => "\x53",
     0x00000442 => "\x54",
     0x00000443 => "\x55",
     0x00000444 => "\x46",
     0x00000445 => "\x48",
     0x00000446 => "\x43",
     0x00000447 => "\x5e",
     0x00000448 => "\x5b",
     0x00000449 => "\x5d",
     0x0000044a => "\x5f",
     0x0000044b => "\x59",
     0x0000044c => "\x58",
     0x0000044d => "\x5c",
     0x0000044e => "\x40",
     0x0000044f => "\x51",
     0x0000207a => "\x3f",
     0x0000207b => "\x3e",
     0x00002192 => "\x2e",
     0x0000221a => "\x2c",
     0x0000222b => "\x2f",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_10367_BOX.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_10367_BOX;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x2551,
     0x2550,
     0x2554,
     0x2557,
     0x255a,
     0x255d,
     0x2560,
     0x2563,
     0x2566,
     0x2569,
     0x256c,
     0xe019,
     0x2584,
     0x2588,
     0x25aa,
     0xfffd,
     0x2502,
     0x2500,
     0x250c,
     0x2510,
     0x2514,
     0x2518,
     0x251c,
     0x2524,
     0x252c,
     0x2534,
     0x253c,
     0x2591,
     0x2592,
     0x2593,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x95\x91",
     "\xe2\x95\x90",
     "\xe2\x95\x94",
     "\xe2\x95\x97",
     "\xe2\x95\x9a",
     "\xe2\x95\x9d",
     "\xe2\x95\xa0",
     "\xe2\x95\xa3",
     "\xe2\x95\xa6",
     "\xe2\x95\xa9",
     "\xe2\x95\xac",
     "\xee\x80\x99",
     "\xe2\x96\x84",
     "\xe2\x96\x88",
     "\xe2\x96\xaa",
     "\xef\xbf\xbd",
     "\xe2\x94\x82",
     "\xe2\x94\x80",
     "\xe2\x94\x8c",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\x98",
     "\xe2\x94\x9c",
     "\xe2\x94\xa4",
     "\xe2\x94\xac",
     "\xe2\x94\xb4",
     "\xe2\x94\xbc",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x00002500 => "\xd1",
     0x00002502 => "\xd0",
     0x0000250c => "\xd2",
     0x00002510 => "\xd3",
     0x00002514 => "\xd4",
     0x00002518 => "\xd5",
     0x0000251c => "\xd6",
     0x00002524 => "\xd7",
     0x0000252c => "\xd8",
     0x00002534 => "\xd9",
     0x0000253c => "\xda",
     0x00002550 => "\xc1",
     0x00002551 => "\xc0",
     0x00002554 => "\xc2",
     0x00002557 => "\xc3",
     0x0000255a => "\xc4",
     0x0000255d => "\xc5",
     0x00002560 => "\xc6",
     0x00002563 => "\xc7",
     0x00002566 => "\xc8",
     0x00002569 => "\xc9",
     0x0000256c => "\xca",
     0x00002584 => "\xcc",
     0x00002588 => "\xcd",
     0x00002591 => "\xdb",
     0x00002592 => "\xdc",
     0x00002593 => "\xdd",
     0x000025aa => "\xce",
     0x0000e019 => "\xcb",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_2033_1983.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_2033_1983;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x2446,
     0x2447,
     0x2448,
     0x2449,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xe2\x91\x86",
     "\xe2\x91\x87",
     "\xe2\x91\x88",
     "\xe2\x91\x89",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000007f => "\x7f",
     0x00002446 => "\x3a",
     0x00002447 => "\x3b",
     0x00002448 => "\x3c",
     0x00002449 => "\x3d",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_5427.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_5427;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x00a4,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x044e,
     0x0430,
     0x0431,
     0x0446,
     0x0434,
     0x0435,
     0x0444,
     0x0433,
     0x0445,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x044f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0436,
     0x0432,
     0x044c,
     0x044b,
     0x0437,
     0x0448,
     0x044d,
     0x0449,
     0x0447,
     0x044a,
     0x042e,
     0x0410,
     0x0411,
     0x0426,
     0x0414,
     0x0415,
     0x0424,
     0x0413,
     0x0425,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x042f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0416,
     0x0412,
     0x042c,
     0x042b,
     0x0417,
     0x0428,
     0x042d,
     0x0429,
     0x0427,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\xc2\xa4",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\xd1\x8e",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd1\x86",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd1\x84",
     "\xd0\xb3",
     "\xd1\x85",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x8f",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd0\xb6",
     "\xd0\xb2",
     "\xd1\x8c",
     "\xd1\x8b",
     "\xd0\xb7",
     "\xd1\x88",
     "\xd1\x8d",
     "\xd1\x89",
     "\xd1\x87",
     "\xd1\x8a",
     "\xd0\xae",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\xa6",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\xa4",
     "\xd0\x93",
     "\xd0\xa5",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xaf",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\x96",
     "\xd0\x92",
     "\xd0\xac",
     "\xd0\xab",
     "\xd0\x97",
     "\xd0\xa8",
     "\xd0\xad",
     "\xd0\xa9",
     "\xd0\xa7",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x0000007f => "\x7f",
     0x000000a4 => "\x24",
     0x00000410 => "\x61",
     0x00000411 => "\x62",
     0x00000412 => "\x77",
     0x00000413 => "\x67",
     0x00000414 => "\x64",
     0x00000415 => "\x65",
     0x00000416 => "\x76",
     0x00000417 => "\x7a",
     0x00000418 => "\x69",
     0x00000419 => "\x6a",
     0x0000041a => "\x6b",
     0x0000041b => "\x6c",
     0x0000041c => "\x6d",
     0x0000041d => "\x6e",
     0x0000041e => "\x6f",
     0x0000041f => "\x70",
     0x00000420 => "\x72",
     0x00000421 => "\x73",
     0x00000422 => "\x74",
     0x00000423 => "\x75",
     0x00000424 => "\x66",
     0x00000425 => "\x68",
     0x00000426 => "\x63",
     0x00000427 => "\x7e",
     0x00000428 => "\x7b",
     0x00000429 => "\x7d",
     0x0000042b => "\x79",
     0x0000042c => "\x78",
     0x0000042d => "\x7c",
     0x0000042e => "\x60",
     0x0000042f => "\x71",
     0x00000430 => "\x41",
     0x00000431 => "\x42",
     0x00000432 => "\x57",
     0x00000433 => "\x47",
     0x00000434 => "\x44",
     0x00000435 => "\x45",
     0x00000436 => "\x56",
     0x00000437 => "\x5a",
     0x00000438 => "\x49",
     0x00000439 => "\x4a",
     0x0000043a => "\x4b",
     0x0000043b => "\x4c",
     0x0000043c => "\x4d",
     0x0000043d => "\x4e",
     0x0000043e => "\x4f",
     0x0000043f => "\x50",
     0x00000440 => "\x52",
     0x00000441 => "\x53",
     0x00000442 => "\x54",
     0x00000443 => "\x55",
     0x00000444 => "\x46",
     0x00000445 => "\x48",
     0x00000446 => "\x43",
     0x00000447 => "\x5e",
     0x00000448 => "\x5b",
     0x00000449 => "\x5d",
     0x0000044a => "\x5f",
     0x0000044b => "\x59",
     0x0000044c => "\x58",
     0x0000044d => "\x5c",
     0x0000044e => "\x40",
     0x0000044f => "\x51",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_5427_EXT.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_5427_EXT;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0491,
     0x0452,
     0x0453,
     0x0454,
     0x0451,
     0x0455,
     0x0456,
     0x0457,
     0x0458,
     0x0459,
     0x045a,
     0x045b,
     0x045c,
     0x045e,
     0x045f,
     0xfffd,
     0x0463,
     0x0473,
     0x0475,
     0x046b,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x005b,
     0xfffd,
     0x005d,
     0xfffd,
     0x005f,
     0x0490,
     0x0402,
     0x0403,
     0x0404,
     0x0401,
     0x0405,
     0x0406,
     0x0407,
     0x0408,
     0x0409,
     0x040a,
     0x040b,
     0x040c,
     0x040e,
     0x040f,
     0x042a,
     0x0462,
     0x0472,
     0x0474,
     0x046a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd2\x91",
     "\xd1\x92",
     "\xd1\x93",
     "\xd1\x94",
     "\xd1\x91",
     "\xd1\x95",
     "\xd1\x96",
     "\xd1\x97",
     "\xd1\x98",
     "\xd1\x99",
     "\xd1\x9a",
     "\xd1\x9b",
     "\xd1\x9c",
     "\xd1\x9e",
     "\xd1\x9f",
     "\xef\xbf\xbd",
     "\xd1\xa3",
     "\xd1\xb3",
     "\xd1\xb5",
     "\xd1\xab",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x5b",
     "\xef\xbf\xbd",
     "\x5d",
     "\xef\xbf\xbd",
     "\x5f",
     "\xd2\x90",
     "\xd0\x82",
     "\xd0\x83",
     "\xd0\x84",
     "\xd0\x81",
     "\xd0\x85",
     "\xd0\x86",
     "\xd0\x87",
     "\xd0\x88",
     "\xd0\x89",
     "\xd0\x8a",
     "\xd0\x8b",
     "\xd0\x8c",
     "\xd0\x8e",
     "\xd0\x8f",
     "\xd0\xaa",
     "\xd1\xa2",
     "\xd1\xb2",
     "\xd1\xb4",
     "\xd1\xaa",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x0000005b => "\x5b",
     0x0000005d => "\x5d",
     0x0000005f => "\x5f",
     0x0000007f => "\x7f",
     0x00000401 => "\x64",
     0x00000402 => "\x61",
     0x00000403 => "\x62",
     0x00000404 => "\x63",
     0x00000405 => "\x65",
     0x00000406 => "\x66",
     0x00000407 => "\x67",
     0x00000408 => "\x68",
     0x00000409 => "\x69",
     0x0000040a => "\x6a",
     0x0000040b => "\x6b",
     0x0000040c => "\x6c",
     0x0000040e => "\x6d",
     0x0000040f => "\x6e",
     0x0000042a => "\x6f",
     0x00000451 => "\x44",
     0x00000452 => "\x41",
     0x00000453 => "\x42",
     0x00000454 => "\x43",
     0x00000455 => "\x45",
     0x00000456 => "\x46",
     0x00000457 => "\x47",
     0x00000458 => "\x48",
     0x00000459 => "\x49",
     0x0000045a => "\x4a",
     0x0000045b => "\x4b",
     0x0000045c => "\x4c",
     0x0000045e => "\x4d",
     0x0000045f => "\x4e",
     0x00000462 => "\x70",
     0x00000463 => "\x50",
     0x0000046a => "\x73",
     0x0000046b => "\x53",
     0x00000472 => "\x71",
     0x00000473 => "\x51",
     0x00000474 => "\x72",
     0x00000475 => "\x52",
     0x00000490 => "\x60",
     0x00000491 => "\x40",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_5428.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_5428;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0xe002,
     0xe003,
     0xe009,
     0xe005,
     0xe012,
     0xe013,
     0xe014,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00ab,
     0x00bb,
     0x201d,
     0x201c,
     0x0374,
     0x0375,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00b7,
     0xfffd,
     0xfffd,
     0xfffd,
     0x003b,
     0xfffd,
     0x0391,
     0x0392,
     0xfffd,
     0x0393,
     0x0394,
     0x0395,
     0x03da,
     0x03dc,
     0x0396,
     0x0397,
     0x0398,
     0x0399,
     0x039a,
     0x039b,
     0x039c,
     0x039d,
     0x039e,
     0x039f,
     0x03a0,
     0x03de,
     0x03a1,
     0x03a3,
     0xfffd,
     0x03a4,
     0x03a5,
     0x03a6,
     0x03a7,
     0x03a8,
     0x03a9,
     0x03e0,
     0xfffd,
     0xfffd,
     0x03b1,
     0x03b2,
     0x03d0,
     0x03b3,
     0x03b4,
     0x03b5,
     0xe01a,
     0xe01b,
     0x03b6,
     0x03b7,
     0x03b8,
     0x03b9,
     0x03ba,
     0x03bb,
     0x03bc,
     0x03bd,
     0x03be,
     0x03bf,
     0x03c0,
     0xe01c,
     0x03c1,
     0x03c3,
     0x03c2,
     0x03c4,
     0x03c5,
     0x03c6,
     0x03c7,
     0x03c8,
     0x03c9,
     0xe01d,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\xee\x80\x82",
     "\xee\x80\x83",
     "\xee\x80\x89",
     "\xee\x80\x85",
     "\xee\x80\x92",
     "\xee\x80\x93",
     "\xee\x80\x94",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\x9d",
     "\xe2\x80\x9c",
     "\xcd\xb4",
     "\xcd\xb5",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xb7",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\x3b",
     "\xef\xbf\xbd",
     "\xce\x91",
     "\xce\x92",
     "\xef\xbf\xbd",
     "\xce\x93",
     "\xce\x94",
     "\xce\x95",
     "\xcf\x9a",
     "\xcf\x9c",
     "\xce\x96",
     "\xce\x97",
     "\xce\x98",
     "\xce\x99",
     "\xce\x9a",
     "\xce\x9b",
     "\xce\x9c",
     "\xce\x9d",
     "\xce\x9e",
     "\xce\x9f",
     "\xce\xa0",
     "\xcf\x9e",
     "\xce\xa1",
     "\xce\xa3",
     "\xef\xbf\xbd",
     "\xce\xa4",
     "\xce\xa5",
     "\xce\xa6",
     "\xce\xa7",
     "\xce\xa8",
     "\xce\xa9",
     "\xcf\xa0",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xce\xb1",
     "\xce\xb2",
     "\xcf\x90",
     "\xce\xb3",
     "\xce\xb4",
     "\xce\xb5",
     "\xee\x80\x9a",
     "\xee\x80\x9b",
     "\xce\xb6",
     "\xce\xb7",
     "\xce\xb8",
     "\xce\xb9",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xce\xbd",
     "\xce\xbe",
     "\xce\xbf",
     "\xcf\x80",
     "\xee\x80\x9c",
     "\xcf\x81",
     "\xcf\x83",
     "\xcf\x82",
     "\xcf\x84",
     "\xcf\x85",
     "\xcf\x86",
     "\xcf\x87",
     "\xcf\x88",
     "\xcf\x89",
     "\xee\x80\x9d",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x0000003b => "\x3f",
     0x0000007f => "\x7f",
     0x000000ab => "\x30",
     0x000000b7 => "\x3b",
     0x000000bb => "\x31",
     0x00000374 => "\x34",
     0x00000375 => "\x35",
     0x00000391 => "\x41",
     0x00000392 => "\x42",
     0x00000393 => "\x44",
     0x00000394 => "\x45",
     0x00000395 => "\x46",
     0x00000396 => "\x49",
     0x00000397 => "\x4a",
     0x00000398 => "\x4b",
     0x00000399 => "\x4c",
     0x0000039a => "\x4d",
     0x0000039b => "\x4e",
     0x0000039c => "\x4f",
     0x0000039d => "\x50",
     0x0000039e => "\x51",
     0x0000039f => "\x52",
     0x000003a0 => "\x53",
     0x000003a1 => "\x55",
     0x000003a3 => "\x56",
     0x000003a4 => "\x58",
     0x000003a5 => "\x59",
     0x000003a6 => "\x5a",
     0x000003a7 => "\x5b",
     0x000003a8 => "\x5c",
     0x000003a9 => "\x5d",
     0x000003b1 => "\x61",
     0x000003b2 => "\x62",
     0x000003b3 => "\x64",
     0x000003b4 => "\x65",
     0x000003b5 => "\x66",
     0x000003b6 => "\x69",
     0x000003b7 => "\x6a",
     0x000003b8 => "\x6b",
     0x000003b9 => "\x6c",
     0x000003ba => "\x6d",
     0x000003bb => "\x6e",
     0x000003bc => "\x6f",
     0x000003bd => "\x70",
     0x000003be => "\x71",
     0x000003bf => "\x72",
     0x000003c0 => "\x73",
     0x000003c1 => "\x75",
     0x000003c2 => "\x77",
     0x000003c3 => "\x76",
     0x000003c4 => "\x78",
     0x000003c5 => "\x79",
     0x000003c6 => "\x7a",
     0x000003c7 => "\x7b",
     0x000003c8 => "\x7c",
     0x000003c9 => "\x7d",
     0x000003d0 => "\x63",
     0x000003da => "\x47",
     0x000003dc => "\x48",
     0x000003de => "\x54",
     0x000003e0 => "\x5e",
     0x0000201c => "\x33",
     0x0000201d => "\x32",
     0x0000e002 => "\x21",
     0x0000e003 => "\x22",
     0x0000e005 => "\x24",
     0x0000e009 => "\x23",
     0x0000e012 => "\x25",
     0x0000e013 => "\x26",
     0x0000e014 => "\x27",
     0x0000e01a => "\x67",
     0x0000e01b => "\x68",
     0x0000e01c => "\x74",
     0x0000e01d => "\x7e",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_1.pm ###
 #! /bin/false
 
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_1;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 use constant TO_UTF8 => [
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xc2\xa1",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xc2\xa5",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xc2\xaa",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc2\xaf",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc2\xb8",
     "\xc2\xb9",
     "\xc2\xba",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xbf",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x86",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x90",
     "\xc3\x91",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xc3\x97",
     "\xc3\x98",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc3\x9f",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb0",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc3\xb8",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc3\xbf",
 ];
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '', 
 		    map $_ > 255 ? "\x3f" : chr $_,
 			    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8') {
 		$_[1] = join '', map TO_UTF8->[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ unpack 'C*', $_[1] ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_10.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_10;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x0104,
     0x0112,
     0x0122,
     0x012a,
     0x0128,
     0x0136,
     0x00a7,
     0x013b,
     0x0110,
     0x0160,
     0x0166,
     0x017d,
     0x00ad,
     0x016a,
     0x014a,
     0x00b0,
     0x0105,
     0x0113,
     0x0123,
     0x012b,
     0x0129,
     0x0137,
     0x00b7,
     0x013c,
     0x0111,
     0x0161,
     0x0167,
     0x017e,
     0x2015,
     0x016b,
     0x014b,
     0x0100,
     0x00c1,
     0x00c2,
     0x00c3,
     0x00c4,
     0x00c5,
     0x00c6,
     0x012e,
     0x010c,
     0x00c9,
     0x0118,
     0x00cb,
     0x0116,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00d0,
     0x0145,
     0x014c,
     0x00d3,
     0x00d4,
     0x00d5,
     0x00d6,
     0x0168,
     0x00d8,
     0x0172,
     0x00da,
     0x00db,
     0x00dc,
     0x00dd,
     0x00de,
     0x00df,
     0x0101,
     0x00e1,
     0x00e2,
     0x00e3,
     0x00e4,
     0x00e5,
     0x00e6,
     0x012f,
     0x010d,
     0x00e9,
     0x0119,
     0x00eb,
     0x0117,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00f0,
     0x0146,
     0x014d,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x0169,
     0x00f8,
     0x0173,
     0x00fa,
     0x00fb,
     0x00fc,
     0x00fd,
     0x00fe,
     0x0138,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xc4\x84",
     "\xc4\x92",
     "\xc4\xa2",
     "\xc4\xaa",
     "\xc4\xa8",
     "\xc4\xb6",
     "\xc2\xa7",
     "\xc4\xbb",
     "\xc4\x90",
     "\xc5\xa0",
     "\xc5\xa6",
     "\xc5\xbd",
     "\xc2\xad",
     "\xc5\xaa",
     "\xc5\x8a",
     "\xc2\xb0",
     "\xc4\x85",
     "\xc4\x93",
     "\xc4\xa3",
     "\xc4\xab",
     "\xc4\xa9",
     "\xc4\xb7",
     "\xc2\xb7",
     "\xc4\xbc",
     "\xc4\x91",
     "\xc5\xa1",
     "\xc5\xa7",
     "\xc5\xbe",
     "\xe2\x80\x95",
     "\xc5\xab",
     "\xc5\x8b",
     "\xc4\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x86",
     "\xc4\xae",
     "\xc4\x8c",
     "\xc3\x89",
     "\xc4\x98",
     "\xc3\x8b",
     "\xc4\x96",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x90",
     "\xc5\x85",
     "\xc5\x8c",
     "\xc3\x93",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xc5\xa8",
     "\xc3\x98",
     "\xc5\xb2",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc3\x9f",
     "\xc4\x81",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa6",
     "\xc4\xaf",
     "\xc4\x8d",
     "\xc3\xa9",
     "\xc4\x99",
     "\xc3\xab",
     "\xc4\x97",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb0",
     "\xc5\x86",
     "\xc5\x8d",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc5\xa9",
     "\xc3\xb8",
     "\xc5\xb3",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc4\xb8",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a7 => "\xa7",
     0x000000ad => "\xad",
     0x000000b0 => "\xb0",
     0x000000b7 => "\xb7",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c3 => "\xc3",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xc6",
     0x000000c9 => "\xc9",
     0x000000cb => "\xcb",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000cf => "\xcf",
     0x000000d0 => "\xd0",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d8 => "\xd8",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000dd => "\xdd",
     0x000000de => "\xde",
     0x000000df => "\xdf",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e3 => "\xe3",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xe6",
     0x000000e9 => "\xe9",
     0x000000eb => "\xeb",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f0 => "\xf0",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f8 => "\xf8",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000fd => "\xfd",
     0x000000fe => "\xfe",
     0x00000100 => "\xc0",
     0x00000101 => "\xe0",
     0x00000104 => "\xa1",
     0x00000105 => "\xb1",
     0x0000010c => "\xc8",
     0x0000010d => "\xe8",
     0x00000110 => "\xa9",
     0x00000111 => "\xb9",
     0x00000112 => "\xa2",
     0x00000113 => "\xb2",
     0x00000116 => "\xcc",
     0x00000117 => "\xec",
     0x00000118 => "\xca",
     0x00000119 => "\xea",
     0x00000122 => "\xa3",
     0x00000123 => "\xb3",
     0x00000128 => "\xa5",
     0x00000129 => "\xb5",
     0x0000012a => "\xa4",
     0x0000012b => "\xb4",
     0x0000012e => "\xc7",
     0x0000012f => "\xe7",
     0x00000136 => "\xa6",
     0x00000137 => "\xb6",
     0x00000138 => "\xff",
     0x0000013b => "\xa8",
     0x0000013c => "\xb8",
     0x00000145 => "\xd1",
     0x00000146 => "\xf1",
     0x0000014a => "\xaf",
     0x0000014b => "\xbf",
     0x0000014c => "\xd2",
     0x0000014d => "\xf2",
     0x00000160 => "\xaa",
     0x00000161 => "\xba",
     0x00000166 => "\xab",
     0x00000167 => "\xbb",
     0x00000168 => "\xd7",
     0x00000169 => "\xf7",
     0x0000016a => "\xae",
     0x0000016b => "\xbe",
     0x00000172 => "\xd9",
     0x00000173 => "\xf9",
     0x0000017d => "\xac",
     0x0000017e => "\xbc",
     0x00002015 => "\xbd",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_11.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_11;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
 	0xfffd,
     0x00a0,
     0x0e01,
     0x0e02,
     0x0e03,
     0x0e04,
     0x0e05,
     0x0e06,
     0x0e07,
     0x0e08,
     0x0e09,
     0x0e0a,
     0x0e0b,
     0x0e0c,
     0x0e0d,
     0x0e0e,
     0x0e0f,
     0x0e10,
     0x0e11,
     0x0e12,
     0x0e13,
     0x0e14,
     0x0e15,
     0x0e16,
     0x0e17,
     0x0e18,
     0x0e19,
     0x0e1a,
     0x0e1b,
     0x0e1c,
     0x0e1d,
     0x0e1e,
     0x0e1f,
     0x0e20,
     0x0e21,
     0x0e22,
     0x0e23,
     0x0e24,
     0x0e25,
     0x0e26,
     0x0e27,
     0x0e28,
     0x0e29,
     0x0e2a,
     0x0e2b,
     0x0e2c,
     0x0e2d,
     0x0e2e,
     0x0e2f,
     0x0e30,
     0x0e31,
     0x0e32,
     0x0e33,
     0x0e34,
     0x0e35,
     0x0e36,
     0x0e37,
     0x0e38,
     0x0e39,
     0x0e3a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0e3f,
     0x0e40,
     0x0e41,
     0x0e42,
     0x0e43,
     0x0e44,
     0x0e45,
     0x0e46,
     0x0e47,
     0x0e48,
     0x0e49,
     0x0e4a,
     0x0e4b,
     0x0e4c,
     0x0e4d,
     0x0e4e,
     0x0e4f,
     0x0e50,
     0x0e51,
     0x0e52,
     0x0e53,
     0x0e54,
     0x0e55,
     0x0e56,
     0x0e57,
     0x0e58,
     0x0e59,
     0x0e5a,
     0x0e5b,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa0",
     "\xe0\xb8\x81",
     "\xe0\xb8\x82",
     "\xe0\xb8\x83",
     "\xe0\xb8\x84",
     "\xe0\xb8\x85",
     "\xe0\xb8\x86",
     "\xe0\xb8\x87",
     "\xe0\xb8\x88",
     "\xe0\xb8\x89",
     "\xe0\xb8\x8a",
     "\xe0\xb8\x8b",
     "\xe0\xb8\x8c",
     "\xe0\xb8\x8d",
     "\xe0\xb8\x8e",
     "\xe0\xb8\x8f",
     "\xe0\xb8\x90",
     "\xe0\xb8\x91",
     "\xe0\xb8\x92",
     "\xe0\xb8\x93",
     "\xe0\xb8\x94",
     "\xe0\xb8\x95",
     "\xe0\xb8\x96",
     "\xe0\xb8\x97",
     "\xe0\xb8\x98",
     "\xe0\xb8\x99",
     "\xe0\xb8\x9a",
     "\xe0\xb8\x9b",
     "\xe0\xb8\x9c",
     "\xe0\xb8\x9d",
     "\xe0\xb8\x9e",
     "\xe0\xb8\x9f",
     "\xe0\xb8\xa0",
     "\xe0\xb8\xa1",
     "\xe0\xb8\xa2",
     "\xe0\xb8\xa3",
     "\xe0\xb8\xa4",
     "\xe0\xb8\xa5",
     "\xe0\xb8\xa6",
     "\xe0\xb8\xa7",
     "\xe0\xb8\xa8",
     "\xe0\xb8\xa9",
     "\xe0\xb8\xaa",
     "\xe0\xb8\xab",
     "\xe0\xb8\xac",
     "\xe0\xb8\xad",
     "\xe0\xb8\xae",
     "\xe0\xb8\xaf",
     "\xe0\xb8\xb0",
     "\xe0\xb8\xb1",
     "\xe0\xb8\xb2",
     "\xe0\xb8\xb3",
     "\xe0\xb8\xb4",
     "\xe0\xb8\xb5",
     "\xe0\xb8\xb6",
     "\xe0\xb8\xb7",
     "\xe0\xb8\xb8",
     "\xe0\xb8\xb9",
     "\xe0\xb8\xba",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe0\xb8\xbf",
     "\xe0\xb9\x80",
     "\xe0\xb9\x81",
     "\xe0\xb9\x82",
     "\xe0\xb9\x83",
     "\xe0\xb9\x84",
     "\xe0\xb9\x85",
     "\xe0\xb9\x86",
     "\xe0\xb9\x87",
     "\xe0\xb9\x88",
     "\xe0\xb9\x89",
     "\xe0\xb9\x8a",
     "\xe0\xb9\x8b",
     "\xe0\xb9\x8c",
     "\xe0\xb9\x8d",
     "\xe0\xb9\x8e",
     "\xe0\xb9\x8f",
     "\xe0\xb9\x90",
     "\xe0\xb9\x91",
     "\xe0\xb9\x92",
     "\xe0\xb9\x93",
     "\xe0\xb9\x94",
     "\xe0\xb9\x95",
     "\xe0\xb9\x96",
     "\xe0\xb9\x97",
     "\xe0\xb9\x98",
     "\xe0\xb9\x99",
     "\xe0\xb9\x9a",
     "\xe0\xb9\x9b",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x00000e01 => "\xa1",
     0x00000e02 => "\xa2",
     0x00000e03 => "\xa3",
     0x00000e04 => "\xa4",
     0x00000e05 => "\xa5",
     0x00000e06 => "\xa6",
     0x00000e07 => "\xa7",
     0x00000e08 => "\xa8",
     0x00000e09 => "\xa9",
     0x00000e0a => "\xaa",
     0x00000e0b => "\xab",
     0x00000e0c => "\xac",
     0x00000e0d => "\xad",
     0x00000e0e => "\xae",
     0x00000e0f => "\xaf",
     0x00000e10 => "\xb0",
     0x00000e11 => "\xb1",
     0x00000e12 => "\xb2",
     0x00000e13 => "\xb3",
     0x00000e14 => "\xb4",
     0x00000e15 => "\xb5",
     0x00000e16 => "\xb6",
     0x00000e17 => "\xb7",
     0x00000e18 => "\xb8",
     0x00000e19 => "\xb9",
     0x00000e1a => "\xba",
     0x00000e1b => "\xbb",
     0x00000e1c => "\xbc",
     0x00000e1d => "\xbd",
     0x00000e1e => "\xbe",
     0x00000e1f => "\xbf",
     0x00000e20 => "\xc0",
     0x00000e21 => "\xc1",
     0x00000e22 => "\xc2",
     0x00000e23 => "\xc3",
     0x00000e24 => "\xc4",
     0x00000e25 => "\xc5",
     0x00000e26 => "\xc6",
     0x00000e27 => "\xc7",
     0x00000e28 => "\xc8",
     0x00000e29 => "\xc9",
     0x00000e2a => "\xca",
     0x00000e2b => "\xcb",
     0x00000e2c => "\xcc",
     0x00000e2d => "\xcd",
     0x00000e2e => "\xce",
     0x00000e2f => "\xcf",
     0x00000e30 => "\xd0",
     0x00000e31 => "\xd1",
     0x00000e32 => "\xd2",
     0x00000e33 => "\xd3",
     0x00000e34 => "\xd4",
     0x00000e35 => "\xd5",
     0x00000e36 => "\xd6",
     0x00000e37 => "\xd7",
     0x00000e38 => "\xd8",
     0x00000e39 => "\xd9",
     0x00000e3a => "\xda",
     0x00000e3f => "\xdf",
     0x00000e40 => "\xe0",
     0x00000e41 => "\xe1",
     0x00000e42 => "\xe2",
     0x00000e43 => "\xe3",
     0x00000e44 => "\xe4",
     0x00000e45 => "\xe5",
     0x00000e46 => "\xe6",
     0x00000e47 => "\xe7",
     0x00000e48 => "\xe8",
     0x00000e49 => "\xe9",
     0x00000e4a => "\xea",
     0x00000e4b => "\xeb",
     0x00000e4c => "\xec",
     0x00000e4d => "\xed",
     0x00000e4e => "\xee",
     0x00000e4f => "\xef",
     0x00000e50 => "\xf0",
     0x00000e51 => "\xf1",
     0x00000e52 => "\xf2",
     0x00000e53 => "\xf3",
     0x00000e54 => "\xf4",
     0x00000e55 => "\xf5",
     0x00000e56 => "\xf6",
     0x00000e57 => "\xf7",
     0x00000e58 => "\xf8",
     0x00000e59 => "\xf9",
     0x00000e5a => "\xfa",
     0x00000e5b => "\xfb",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_13.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_13;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x201d,
     0x00a2,
     0x00a3,
     0x00a4,
     0x201e,
     0x00a6,
     0x00a7,
     0x00d8,
     0x00a9,
     0x0156,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x00c6,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x201c,
     0x00b5,
     0x00b6,
     0x00b7,
     0x00f8,
     0x00b9,
     0x0157,
     0x00bb,
     0x00bc,
     0x00bd,
     0x00be,
     0x00e6,
     0x0104,
     0x012e,
     0x0100,
     0x0106,
     0x00c4,
     0x00c5,
     0x0118,
     0x0112,
     0x010c,
     0x00c9,
     0x0179,
     0x0116,
     0x0122,
     0x0136,
     0x012a,
     0x013b,
     0x0160,
     0x0143,
     0x0145,
     0x00d3,
     0x014c,
     0x00d5,
     0x00d6,
     0x00d7,
     0x0172,
     0x0141,
     0x015a,
     0x016a,
     0x00dc,
     0x017b,
     0x017d,
     0x00df,
     0x0105,
     0x012f,
     0x0101,
     0x0107,
     0x00e4,
     0x00e5,
     0x0119,
     0x0113,
     0x010d,
     0x00e9,
     0x017a,
     0x0117,
     0x0123,
     0x0137,
     0x012b,
     0x013c,
     0x0161,
     0x0144,
     0x0146,
     0x00f3,
     0x014d,
     0x00f5,
     0x00f6,
     0x00f7,
     0x0173,
     0x0142,
     0x015b,
     0x016b,
     0x00fc,
     0x017c,
     0x017e,
     0x2019,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xe2\x80\x9d",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xe2\x80\x9e",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc3\x98",
     "\xc2\xa9",
     "\xc5\x96",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc3\x86",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xe2\x80\x9c",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc3\xb8",
     "\xc2\xb9",
     "\xc5\x97",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc3\xa6",
     "\xc4\x84",
     "\xc4\xae",
     "\xc4\x80",
     "\xc4\x86",
     "\xc3\x84",
     "\xc3\x85",
     "\xc4\x98",
     "\xc4\x92",
     "\xc4\x8c",
     "\xc3\x89",
     "\xc5\xb9",
     "\xc4\x96",
     "\xc4\xa2",
     "\xc4\xb6",
     "\xc4\xaa",
     "\xc4\xbb",
     "\xc5\xa0",
     "\xc5\x83",
     "\xc5\x85",
     "\xc3\x93",
     "\xc5\x8c",
     "\xc3\x95",
     "\xc3\x96",
     "\xc3\x97",
     "\xc5\xb2",
     "\xc5\x81",
     "\xc5\x9a",
     "\xc5\xaa",
     "\xc3\x9c",
     "\xc5\xbb",
     "\xc5\xbd",
     "\xc3\x9f",
     "\xc4\x85",
     "\xc4\xaf",
     "\xc4\x81",
     "\xc4\x87",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc4\x99",
     "\xc4\x93",
     "\xc4\x8d",
     "\xc3\xa9",
     "\xc5\xba",
     "\xc4\x97",
     "\xc4\xa3",
     "\xc4\xb7",
     "\xc4\xab",
     "\xc4\xbc",
     "\xc5\xa1",
     "\xc5\x84",
     "\xc5\x86",
     "\xc3\xb3",
     "\xc5\x8d",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc5\xb3",
     "\xc5\x82",
     "\xc5\x9b",
     "\xc5\xab",
     "\xc3\xbc",
     "\xc5\xbc",
     "\xc5\xbe",
     "\xe2\x80\x99",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a9 => "\xa9",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b9 => "\xb9",
     0x000000bb => "\xbb",
     0x000000bc => "\xbc",
     0x000000bd => "\xbd",
     0x000000be => "\xbe",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xaf",
     0x000000c9 => "\xc9",
     0x000000d3 => "\xd3",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000d8 => "\xa8",
     0x000000dc => "\xdc",
     0x000000df => "\xdf",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xbf",
     0x000000e9 => "\xe9",
     0x000000f3 => "\xf3",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f8 => "\xb8",
     0x000000fc => "\xfc",
     0x00000100 => "\xc2",
     0x00000101 => "\xe2",
     0x00000104 => "\xc0",
     0x00000105 => "\xe0",
     0x00000106 => "\xc3",
     0x00000107 => "\xe3",
     0x0000010c => "\xc8",
     0x0000010d => "\xe8",
     0x00000112 => "\xc7",
     0x00000113 => "\xe7",
     0x00000116 => "\xcb",
     0x00000117 => "\xeb",
     0x00000118 => "\xc6",
     0x00000119 => "\xe6",
     0x00000122 => "\xcc",
     0x00000123 => "\xec",
     0x0000012a => "\xce",
     0x0000012b => "\xee",
     0x0000012e => "\xc1",
     0x0000012f => "\xe1",
     0x00000136 => "\xcd",
     0x00000137 => "\xed",
     0x0000013b => "\xcf",
     0x0000013c => "\xef",
     0x00000141 => "\xd9",
     0x00000142 => "\xf9",
     0x00000143 => "\xd1",
     0x00000144 => "\xf1",
     0x00000145 => "\xd2",
     0x00000146 => "\xf2",
     0x0000014c => "\xd4",
     0x0000014d => "\xf4",
     0x00000156 => "\xaa",
     0x00000157 => "\xba",
     0x0000015a => "\xda",
     0x0000015b => "\xfa",
     0x00000160 => "\xd0",
     0x00000161 => "\xf0",
     0x0000016a => "\xdb",
     0x0000016b => "\xfb",
     0x00000172 => "\xd8",
     0x00000173 => "\xf8",
     0x00000179 => "\xca",
     0x0000017a => "\xea",
     0x0000017b => "\xdd",
     0x0000017c => "\xfd",
     0x0000017d => "\xde",
     0x0000017e => "\xfe",
     0x00002019 => "\xff",
     0x0000201c => "\xb4",
     0x0000201d => "\xa1",
     0x0000201e => "\xa5",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_14.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_14;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x1e02,
     0x1e03,
     0x00a3,
     0x010a,
     0x010b,
     0x1e0a,
     0x00a7,
     0x1e80,
     0x00a9,
     0x1e82,
     0x1e0b,
     0x1ef2,
     0x00ad,
     0x00ae,
     0x0178,
     0x1e1e,
     0x1e1f,
     0x0120,
     0x0121,
     0x1e40,
     0x1e41,
     0x00b6,
     0x1e56,
     0x1e81,
     0x1e57,
     0x1e83,
     0x1e60,
     0x1ef3,
     0x1e84,
     0x1e85,
     0x1e61,
     0x00c0,
     0x00c1,
     0x00c2,
     0x00c3,
     0x00c4,
     0x00c5,
     0x00c6,
     0x00c7,
     0x00c8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00cc,
     0x00cd,
     0x00ce,
     0x00cf,
     0x0174,
     0x00d1,
     0x00d2,
     0x00d3,
     0x00d4,
     0x00d5,
     0x00d6,
     0x1e6a,
     0x00d8,
     0x00d9,
     0x00da,
     0x00db,
     0x00dc,
     0x00dd,
     0x0176,
     0x00df,
     0x00e0,
     0x00e1,
     0x00e2,
     0x00e3,
     0x00e4,
     0x00e5,
     0x00e6,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0x0175,
     0x00f1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x1e6b,
     0x00f8,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x00fd,
     0x0177,
     0x00ff,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xe1\xb8\x82",
     "\xe1\xb8\x83",
     "\xc2\xa3",
     "\xc4\x8a",
     "\xc4\x8b",
     "\xe1\xb8\x8a",
     "\xc2\xa7",
     "\xe1\xba\x80",
     "\xc2\xa9",
     "\xe1\xba\x82",
     "\xe1\xb8\x8b",
     "\xe1\xbb\xb2",
     "\xc2\xad",
     "\xc2\xae",
     "\xc5\xb8",
     "\xe1\xb8\x9e",
     "\xe1\xb8\x9f",
     "\xc4\xa0",
     "\xc4\xa1",
     "\xe1\xb9\x80",
     "\xe1\xb9\x81",
     "\xc2\xb6",
     "\xe1\xb9\x96",
     "\xe1\xba\x81",
     "\xe1\xb9\x97",
     "\xe1\xba\x83",
     "\xe1\xb9\xa0",
     "\xe1\xbb\xb3",
     "\xe1\xba\x84",
     "\xe1\xba\x85",
     "\xe1\xb9\xa1",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x86",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc5\xb4",
     "\xc3\x91",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xe1\xb9\xaa",
     "\xc3\x98",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x9d",
     "\xc5\xb6",
     "\xc3\x9f",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc5\xb5",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xe1\xb9\xab",
     "\xc3\xb8",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc5\xb7",
     "\xc3\xbf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a3 => "\xa3",
     0x000000a7 => "\xa7",
     0x000000a9 => "\xa9",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000b6 => "\xb6",
     0x000000c0 => "\xc0",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c3 => "\xc3",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xc6",
     0x000000c7 => "\xc7",
     0x000000c8 => "\xc8",
     0x000000c9 => "\xc9",
     0x000000ca => "\xca",
     0x000000cb => "\xcb",
     0x000000cc => "\xcc",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000cf => "\xcf",
     0x000000d1 => "\xd1",
     0x000000d2 => "\xd2",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d8 => "\xd8",
     0x000000d9 => "\xd9",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000dd => "\xdd",
     0x000000df => "\xdf",
     0x000000e0 => "\xe0",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e3 => "\xe3",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xe6",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f1 => "\xf1",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f8 => "\xf8",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000fd => "\xfd",
     0x000000ff => "\xff",
     0x0000010a => "\xa4",
     0x0000010b => "\xa5",
     0x00000120 => "\xb2",
     0x00000121 => "\xb3",
     0x00000174 => "\xd0",
     0x00000175 => "\xf0",
     0x00000176 => "\xde",
     0x00000177 => "\xfe",
     0x00000178 => "\xaf",
     0x00001e02 => "\xa1",
     0x00001e03 => "\xa2",
     0x00001e0a => "\xa6",
     0x00001e0b => "\xab",
     0x00001e1e => "\xb0",
     0x00001e1f => "\xb1",
     0x00001e40 => "\xb4",
     0x00001e41 => "\xb5",
     0x00001e56 => "\xb7",
     0x00001e57 => "\xb9",
     0x00001e60 => "\xbb",
     0x00001e61 => "\xbf",
     0x00001e6a => "\xd7",
     0x00001e6b => "\xf7",
     0x00001e80 => "\xa8",
     0x00001e81 => "\xb8",
     0x00001e82 => "\xaa",
     0x00001e83 => "\xba",
     0x00001e84 => "\xbd",
     0x00001e85 => "\xbe",
     0x00001ef2 => "\xac",
     0x00001ef3 => "\xbc",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_15.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_15;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x00a1,
     0x00a2,
     0x00a3,
     0x20ac,
     0x00a5,
     0x0160,
     0x00a7,
     0x0161,
     0x00a9,
     0x00aa,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x00af,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x017d,
     0x00b5,
     0x00b6,
     0x00b7,
     0x017e,
     0x00b9,
     0x00ba,
     0x00bb,
     0x0152,
     0x0153,
     0x0178,
     0x00bf,
     0x00c0,
     0x00c1,
     0x00c2,
     0x00c3,
     0x00c4,
     0x00c5,
     0x00c6,
     0x00c7,
     0x00c8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00cc,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00d0,
     0x00d1,
     0x00d2,
     0x00d3,
     0x00d4,
     0x00d5,
     0x00d6,
     0x00d7,
     0x00d8,
     0x00d9,
     0x00da,
     0x00db,
     0x00dc,
     0x00dd,
     0x00de,
     0x00df,
     0x00e0,
     0x00e1,
     0x00e2,
     0x00e3,
     0x00e4,
     0x00e5,
     0x00e6,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00f0,
     0x00f1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x00f7,
     0x00f8,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x00fd,
     0x00fe,
     0x00ff,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xc2\xa1",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xe2\x82\xac",
     "\xc2\xa5",
     "\xc5\xa0",
     "\xc2\xa7",
     "\xc5\xa1",
     "\xc2\xa9",
     "\xc2\xaa",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc2\xaf",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc5\xbd",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc5\xbe",
     "\xc2\xb9",
     "\xc2\xba",
     "\xc2\xbb",
     "\xc5\x92",
     "\xc5\x93",
     "\xc5\xb8",
     "\xc2\xbf",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x86",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x90",
     "\xc3\x91",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xc3\x97",
     "\xc3\x98",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc3\x9f",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb0",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc3\xb8",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc3\xbf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a1 => "\xa1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a5 => "\xa5",
     0x000000a7 => "\xa7",
     0x000000a9 => "\xa9",
     0x000000aa => "\xaa",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000af => "\xaf",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b9 => "\xb9",
     0x000000ba => "\xba",
     0x000000bb => "\xbb",
     0x000000bf => "\xbf",
     0x000000c0 => "\xc0",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c3 => "\xc3",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xc6",
     0x000000c7 => "\xc7",
     0x000000c8 => "\xc8",
     0x000000c9 => "\xc9",
     0x000000ca => "\xca",
     0x000000cb => "\xcb",
     0x000000cc => "\xcc",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000cf => "\xcf",
     0x000000d0 => "\xd0",
     0x000000d1 => "\xd1",
     0x000000d2 => "\xd2",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000d8 => "\xd8",
     0x000000d9 => "\xd9",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000dd => "\xdd",
     0x000000de => "\xde",
     0x000000df => "\xdf",
     0x000000e0 => "\xe0",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e3 => "\xe3",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xe6",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f0 => "\xf0",
     0x000000f1 => "\xf1",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f8 => "\xf8",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000fd => "\xfd",
     0x000000fe => "\xfe",
     0x000000ff => "\xff",
     0x00000152 => "\xbc",
     0x00000153 => "\xbd",
     0x00000160 => "\xa6",
     0x00000161 => "\xa8",
     0x00000178 => "\xbe",
     0x0000017d => "\xb4",
     0x0000017e => "\xb8",
     0x000020ac => "\xa4",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_16.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_16;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x0104,
     0x0105,
     0x0141,
     0x20ac,
     0x201e,
     0x0160,
     0x00a7,
     0x0161,
     0x00a9,
     0x0218,
     0x00ab,
     0x0179,
     0x00ad,
     0x017a,
     0x017b,
     0x00b0,
     0x00b1,
     0x010c,
     0x0142,
     0x017d,
     0x201d,
     0x00b6,
     0x00b7,
     0x017e,
     0x010d,
     0x0219,
     0x00bb,
     0x0152,
     0x0153,
     0x0178,
     0x017c,
     0x00c0,
     0x00c1,
     0x00c2,
     0x0102,
     0x00c4,
     0x0106,
     0x00c6,
     0x00c7,
     0x00c8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00cc,
     0x00cd,
     0x00ce,
     0x00cf,
     0x0110,
     0x0143,
     0x00d2,
     0x00d3,
     0x00d4,
     0x0150,
     0x00d6,
     0x015a,
     0x0170,
     0x00d9,
     0x00da,
     0x00db,
     0x00dc,
     0x0118,
     0x021a,
     0x00df,
     0x00e0,
     0x00e1,
     0x00e2,
     0x0103,
     0x00e4,
     0x0107,
     0x00e6,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0x0111,
     0x0144,
     0x00f2,
     0x00f3,
     0x00f4,
     0x0151,
     0x00f6,
     0x015b,
     0x0171,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x0119,
     0x021b,
     0x00ff,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xc4\x84",
     "\xc4\x85",
     "\xc5\x81",
     "\xe2\x82\xac",
     "\xe2\x80\x9e",
     "\xc5\xa0",
     "\xc2\xa7",
     "\xc5\xa1",
     "\xc2\xa9",
     "\xc8\x98",
     "\xc2\xab",
     "\xc5\xb9",
     "\xc2\xad",
     "\xc5\xba",
     "\xc5\xbb",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc4\x8c",
     "\xc5\x82",
     "\xc5\xbd",
     "\xe2\x80\x9d",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc5\xbe",
     "\xc4\x8d",
     "\xc8\x99",
     "\xc2\xbb",
     "\xc5\x92",
     "\xc5\x93",
     "\xc5\xb8",
     "\xc5\xbc",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc4\x82",
     "\xc3\x84",
     "\xc4\x86",
     "\xc3\x86",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc4\x90",
     "\xc5\x83",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc5\x90",
     "\xc3\x96",
     "\xc5\x9a",
     "\xc5\xb0",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc4\x98",
     "\xc8\x9a",
     "\xc3\x9f",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc4\x83",
     "\xc3\xa4",
     "\xc4\x87",
     "\xc3\xa6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc4\x91",
     "\xc5\x84",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc5\x91",
     "\xc3\xb6",
     "\xc5\x9b",
     "\xc5\xb1",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc4\x99",
     "\xc8\x9b",
     "\xc3\xbf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a7 => "\xa7",
     0x000000a9 => "\xa9",
     0x000000ab => "\xab",
     0x000000ad => "\xad",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000bb => "\xbb",
     0x000000c0 => "\xc0",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c4 => "\xc4",
     0x000000c6 => "\xc6",
     0x000000c7 => "\xc7",
     0x000000c8 => "\xc8",
     0x000000c9 => "\xc9",
     0x000000ca => "\xca",
     0x000000cb => "\xcb",
     0x000000cc => "\xcc",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000cf => "\xcf",
     0x000000d2 => "\xd2",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d6 => "\xd6",
     0x000000d9 => "\xd9",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000df => "\xdf",
     0x000000e0 => "\xe0",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e4 => "\xe4",
     0x000000e6 => "\xe6",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f6 => "\xf6",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000ff => "\xff",
     0x00000102 => "\xc3",
     0x00000103 => "\xe3",
     0x00000104 => "\xa1",
     0x00000105 => "\xa2",
     0x00000106 => "\xc5",
     0x00000107 => "\xe5",
     0x0000010c => "\xb2",
     0x0000010d => "\xb9",
     0x00000110 => "\xd0",
     0x00000111 => "\xf0",
     0x00000118 => "\xdd",
     0x00000119 => "\xfd",
     0x00000141 => "\xa3",
     0x00000142 => "\xb3",
     0x00000143 => "\xd1",
     0x00000144 => "\xf1",
     0x00000150 => "\xd5",
     0x00000151 => "\xf5",
     0x00000152 => "\xbc",
     0x00000153 => "\xbd",
     0x0000015a => "\xd7",
     0x0000015b => "\xf7",
     0x00000160 => "\xa6",
     0x00000161 => "\xa8",
     0x00000170 => "\xd8",
     0x00000171 => "\xf8",
     0x00000178 => "\xbe",
     0x00000179 => "\xac",
     0x0000017a => "\xae",
     0x0000017b => "\xaf",
     0x0000017c => "\xbf",
     0x0000017d => "\xb4",
     0x0000017e => "\xb8",
     0x00000218 => "\xaa",
     0x00000219 => "\xba",
     0x0000021a => "\xde",
     0x0000021b => "\xfe",
     0x0000201d => "\xb5",
     0x0000201e => "\xa5",
     0x000020ac => "\xa4",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_2.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_2;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x0104,
     0x02d8,
     0x0141,
     0x00a4,
     0x013d,
     0x015a,
     0x00a7,
     0x00a8,
     0x0160,
     0x015e,
     0x0164,
     0x0179,
     0x00ad,
     0x017d,
     0x017b,
     0x00b0,
     0x0105,
     0x02db,
     0x0142,
     0x00b4,
     0x013e,
     0x015b,
     0x02c7,
     0x00b8,
     0x0161,
     0x015f,
     0x0165,
     0x017a,
     0x02dd,
     0x017e,
     0x017c,
     0x0154,
     0x00c1,
     0x00c2,
     0x0102,
     0x00c4,
     0x0139,
     0x0106,
     0x00c7,
     0x010c,
     0x00c9,
     0x0118,
     0x00cb,
     0x011a,
     0x00cd,
     0x00ce,
     0x010e,
     0x0110,
     0x0143,
     0x0147,
     0x00d3,
     0x00d4,
     0x0150,
     0x00d6,
     0x00d7,
     0x0158,
     0x016e,
     0x00da,
     0x0170,
     0x00dc,
     0x00dd,
     0x0162,
     0x00df,
     0x0155,
     0x00e1,
     0x00e2,
     0x0103,
     0x00e4,
     0x013a,
     0x0107,
     0x00e7,
     0x010d,
     0x00e9,
     0x0119,
     0x00eb,
     0x011b,
     0x00ed,
     0x00ee,
     0x010f,
     0x0111,
     0x0144,
     0x0148,
     0x00f3,
     0x00f4,
     0x0151,
     0x00f6,
     0x00f7,
     0x0159,
     0x016f,
     0x00fa,
     0x0171,
     0x00fc,
     0x00fd,
     0x0163,
     0x02d9,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xc4\x84",
     "\xcb\x98",
     "\xc5\x81",
     "\xc2\xa4",
     "\xc4\xbd",
     "\xc5\x9a",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc5\xa0",
     "\xc5\x9e",
     "\xc5\xa4",
     "\xc5\xb9",
     "\xc2\xad",
     "\xc5\xbd",
     "\xc5\xbb",
     "\xc2\xb0",
     "\xc4\x85",
     "\xcb\x9b",
     "\xc5\x82",
     "\xc2\xb4",
     "\xc4\xbe",
     "\xc5\x9b",
     "\xcb\x87",
     "\xc2\xb8",
     "\xc5\xa1",
     "\xc5\x9f",
     "\xc5\xa5",
     "\xc5\xba",
     "\xcb\x9d",
     "\xc5\xbe",
     "\xc5\xbc",
     "\xc5\x94",
     "\xc3\x81",
     "\xc3\x82",
     "\xc4\x82",
     "\xc3\x84",
     "\xc4\xb9",
     "\xc4\x86",
     "\xc3\x87",
     "\xc4\x8c",
     "\xc3\x89",
     "\xc4\x98",
     "\xc3\x8b",
     "\xc4\x9a",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc4\x8e",
     "\xc4\x90",
     "\xc5\x83",
     "\xc5\x87",
     "\xc3\x93",
     "\xc3\x94",
     "\xc5\x90",
     "\xc3\x96",
     "\xc3\x97",
     "\xc5\x98",
     "\xc5\xae",
     "\xc3\x9a",
     "\xc5\xb0",
     "\xc3\x9c",
     "\xc3\x9d",
     "\xc5\xa2",
     "\xc3\x9f",
     "\xc5\x95",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc4\x83",
     "\xc3\xa4",
     "\xc4\xba",
     "\xc4\x87",
     "\xc3\xa7",
     "\xc4\x8d",
     "\xc3\xa9",
     "\xc4\x99",
     "\xc3\xab",
     "\xc4\x9b",
     "\xc3\xad",
     "\xc3\xae",
     "\xc4\x8f",
     "\xc4\x91",
     "\xc5\x84",
     "\xc5\x88",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc5\x91",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc5\x99",
     "\xc5\xaf",
     "\xc3\xba",
     "\xc5\xb1",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc5\xa3",
     "\xcb\x99",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a4 => "\xa4",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000ad => "\xad",
     0x000000b0 => "\xb0",
     0x000000b4 => "\xb4",
     0x000000b8 => "\xb8",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c4 => "\xc4",
     0x000000c7 => "\xc7",
     0x000000c9 => "\xc9",
     0x000000cb => "\xcb",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000da => "\xda",
     0x000000dc => "\xdc",
     0x000000dd => "\xdd",
     0x000000df => "\xdf",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e4 => "\xe4",
     0x000000e7 => "\xe7",
     0x000000e9 => "\xe9",
     0x000000eb => "\xeb",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000fa => "\xfa",
     0x000000fc => "\xfc",
     0x000000fd => "\xfd",
     0x00000102 => "\xc3",
     0x00000103 => "\xe3",
     0x00000104 => "\xa1",
     0x00000105 => "\xb1",
     0x00000106 => "\xc6",
     0x00000107 => "\xe6",
     0x0000010c => "\xc8",
     0x0000010d => "\xe8",
     0x0000010e => "\xcf",
     0x0000010f => "\xef",
     0x00000110 => "\xd0",
     0x00000111 => "\xf0",
     0x00000118 => "\xca",
     0x00000119 => "\xea",
     0x0000011a => "\xcc",
     0x0000011b => "\xec",
     0x00000139 => "\xc5",
     0x0000013a => "\xe5",
     0x0000013d => "\xa5",
     0x0000013e => "\xb5",
     0x00000141 => "\xa3",
     0x00000142 => "\xb3",
     0x00000143 => "\xd1",
     0x00000144 => "\xf1",
     0x00000147 => "\xd2",
     0x00000148 => "\xf2",
     0x00000150 => "\xd5",
     0x00000151 => "\xf5",
     0x00000154 => "\xc0",
     0x00000155 => "\xe0",
     0x00000158 => "\xd8",
     0x00000159 => "\xf8",
     0x0000015a => "\xa6",
     0x0000015b => "\xb6",
     0x0000015e => "\xaa",
     0x0000015f => "\xba",
     0x00000160 => "\xa9",
     0x00000161 => "\xb9",
     0x00000162 => "\xde",
     0x00000163 => "\xfe",
     0x00000164 => "\xab",
     0x00000165 => "\xbb",
     0x0000016e => "\xd9",
     0x0000016f => "\xf9",
     0x00000170 => "\xdb",
     0x00000171 => "\xfb",
     0x00000179 => "\xac",
     0x0000017a => "\xbc",
     0x0000017b => "\xaf",
     0x0000017c => "\xbf",
     0x0000017d => "\xae",
     0x0000017e => "\xbe",
     0x000002c7 => "\xb7",
     0x000002d8 => "\xa2",
     0x000002d9 => "\xff",
     0x000002db => "\xb2",
     0x000002dd => "\xbd",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_3.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_3;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x0126,
     0x02d8,
     0x00a3,
     0x00a4,
     0xfffd,
     0x0124,
     0x00a7,
     0x00a8,
     0x0130,
     0x015e,
     0x011e,
     0x0134,
     0x00ad,
     0xfffd,
     0x017b,
     0x00b0,
     0x0127,
     0x00b2,
     0x00b3,
     0x00b4,
     0x00b5,
     0x0125,
     0x00b7,
     0x00b8,
     0x0131,
     0x015f,
     0x011f,
     0x0135,
     0x00bd,
     0xfffd,
     0x017c,
     0x00c0,
     0x00c1,
     0x00c2,
     0xfffd,
     0x00c4,
     0x010a,
     0x0108,
     0x00c7,
     0x00c8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00cc,
     0x00cd,
     0x00ce,
     0x00cf,
     0xfffd,
     0x00d1,
     0x00d2,
     0x00d3,
     0x00d4,
     0x0120,
     0x00d6,
     0x00d7,
     0x011c,
     0x00d9,
     0x00da,
     0x00db,
     0x00dc,
     0x016c,
     0x015c,
     0x00df,
     0x00e0,
     0x00e1,
     0x00e2,
     0xfffd,
     0x00e4,
     0x010b,
     0x0109,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0xfffd,
     0x00f1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x0121,
     0x00f6,
     0x00f7,
     0x011d,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x016d,
     0x015d,
     0x02d9,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xc4\xa6",
     "\xcb\x98",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xef\xbf\xbd",
     "\xc4\xa4",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc4\xb0",
     "\xc5\x9e",
     "\xc4\x9e",
     "\xc4\xb4",
     "\xc2\xad",
     "\xef\xbf\xbd",
     "\xc5\xbb",
     "\xc2\xb0",
     "\xc4\xa7",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc4\xa5",
     "\xc2\xb7",
     "\xc2\xb8",
     "\xc4\xb1",
     "\xc5\x9f",
     "\xc4\x9f",
     "\xc4\xb5",
     "\xc2\xbd",
     "\xef\xbf\xbd",
     "\xc5\xbc",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xef\xbf\xbd",
     "\xc3\x84",
     "\xc4\x8a",
     "\xc4\x88",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xef\xbf\xbd",
     "\xc3\x91",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc4\xa0",
     "\xc3\x96",
     "\xc3\x97",
     "\xc4\x9c",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc5\xac",
     "\xc5\x9c",
     "\xc3\x9f",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xef\xbf\xbd",
     "\xc3\xa4",
     "\xc4\x8b",
     "\xc4\x89",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xef\xbf\xbd",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc4\xa1",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc4\x9d",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc5\xad",
     "\xc5\x9d",
     "\xcb\x99",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000ad => "\xad",
     0x000000b0 => "\xb0",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b7 => "\xb7",
     0x000000b8 => "\xb8",
     0x000000bd => "\xbd",
     0x000000c0 => "\xc0",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c4 => "\xc4",
     0x000000c7 => "\xc7",
     0x000000c8 => "\xc8",
     0x000000c9 => "\xc9",
     0x000000ca => "\xca",
     0x000000cb => "\xcb",
     0x000000cc => "\xcc",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000cf => "\xcf",
     0x000000d1 => "\xd1",
     0x000000d2 => "\xd2",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000d9 => "\xd9",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000df => "\xdf",
     0x000000e0 => "\xe0",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e4 => "\xe4",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f1 => "\xf1",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x00000108 => "\xc6",
     0x00000109 => "\xe6",
     0x0000010a => "\xc5",
     0x0000010b => "\xe5",
     0x0000011c => "\xd8",
     0x0000011d => "\xf8",
     0x0000011e => "\xab",
     0x0000011f => "\xbb",
     0x00000120 => "\xd5",
     0x00000121 => "\xf5",
     0x00000124 => "\xa6",
     0x00000125 => "\xb6",
     0x00000126 => "\xa1",
     0x00000127 => "\xb1",
     0x00000130 => "\xa9",
     0x00000131 => "\xb9",
     0x00000134 => "\xac",
     0x00000135 => "\xbc",
     0x0000015c => "\xde",
     0x0000015d => "\xfe",
     0x0000015e => "\xaa",
     0x0000015f => "\xba",
     0x0000016c => "\xdd",
     0x0000016d => "\xfd",
     0x0000017b => "\xaf",
     0x0000017c => "\xbf",
     0x000002d8 => "\xa2",
     0x000002d9 => "\xff",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_4.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_4;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x0104,
     0x0138,
     0x0156,
     0x00a4,
     0x0128,
     0x013b,
     0x00a7,
     0x00a8,
     0x0160,
     0x0112,
     0x0122,
     0x0166,
     0x00ad,
     0x017d,
     0x00af,
     0x00b0,
     0x0105,
     0x02db,
     0x0157,
     0x00b4,
     0x0129,
     0x013c,
     0x02c7,
     0x00b8,
     0x0161,
     0x0113,
     0x0123,
     0x0167,
     0x014a,
     0x017e,
     0x014b,
     0x0100,
     0x00c1,
     0x00c2,
     0x00c3,
     0x00c4,
     0x00c5,
     0x00c6,
     0x012e,
     0x010c,
     0x00c9,
     0x0118,
     0x00cb,
     0x0116,
     0x00cd,
     0x00ce,
     0x012a,
     0x0110,
     0x0145,
     0x014c,
     0x0136,
     0x00d4,
     0x00d5,
     0x00d6,
     0x00d7,
     0x00d8,
     0x0172,
     0x00da,
     0x00db,
     0x00dc,
     0x0168,
     0x016a,
     0x00df,
     0x0101,
     0x00e1,
     0x00e2,
     0x00e3,
     0x00e4,
     0x00e5,
     0x00e6,
     0x012f,
     0x010d,
     0x00e9,
     0x0119,
     0x00eb,
     0x0117,
     0x00ed,
     0x00ee,
     0x012b,
     0x0111,
     0x0146,
     0x014d,
     0x0137,
     0x00f4,
     0x00f5,
     0x00f6,
     0x00f7,
     0x00f8,
     0x0173,
     0x00fa,
     0x00fb,
     0x00fc,
     0x0169,
     0x016b,
     0x02d9,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xc4\x84",
     "\xc4\xb8",
     "\xc5\x96",
     "\xc2\xa4",
     "\xc4\xa8",
     "\xc4\xbb",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc5\xa0",
     "\xc4\x92",
     "\xc4\xa2",
     "\xc5\xa6",
     "\xc2\xad",
     "\xc5\xbd",
     "\xc2\xaf",
     "\xc2\xb0",
     "\xc4\x85",
     "\xcb\x9b",
     "\xc5\x97",
     "\xc2\xb4",
     "\xc4\xa9",
     "\xc4\xbc",
     "\xcb\x87",
     "\xc2\xb8",
     "\xc5\xa1",
     "\xc4\x93",
     "\xc4\xa3",
     "\xc5\xa7",
     "\xc5\x8a",
     "\xc5\xbe",
     "\xc5\x8b",
     "\xc4\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x86",
     "\xc4\xae",
     "\xc4\x8c",
     "\xc3\x89",
     "\xc4\x98",
     "\xc3\x8b",
     "\xc4\x96",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc4\xaa",
     "\xc4\x90",
     "\xc5\x85",
     "\xc5\x8c",
     "\xc4\xb6",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xc3\x97",
     "\xc3\x98",
     "\xc5\xb2",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc5\xa8",
     "\xc5\xaa",
     "\xc3\x9f",
     "\xc4\x81",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa6",
     "\xc4\xaf",
     "\xc4\x8d",
     "\xc3\xa9",
     "\xc4\x99",
     "\xc3\xab",
     "\xc4\x97",
     "\xc3\xad",
     "\xc3\xae",
     "\xc4\xab",
     "\xc4\x91",
     "\xc5\x86",
     "\xc5\x8d",
     "\xc4\xb7",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc3\xb8",
     "\xc5\xb3",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc5\xa9",
     "\xc5\xab",
     "\xcb\x99",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a4 => "\xa4",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000ad => "\xad",
     0x000000af => "\xaf",
     0x000000b0 => "\xb0",
     0x000000b4 => "\xb4",
     0x000000b8 => "\xb8",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c3 => "\xc3",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xc6",
     0x000000c9 => "\xc9",
     0x000000cb => "\xcb",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000d4 => "\xd4",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000d8 => "\xd8",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000df => "\xdf",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e3 => "\xe3",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xe6",
     0x000000e9 => "\xe9",
     0x000000eb => "\xeb",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f8 => "\xf8",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x00000100 => "\xc0",
     0x00000101 => "\xe0",
     0x00000104 => "\xa1",
     0x00000105 => "\xb1",
     0x0000010c => "\xc8",
     0x0000010d => "\xe8",
     0x00000110 => "\xd0",
     0x00000111 => "\xf0",
     0x00000112 => "\xaa",
     0x00000113 => "\xba",
     0x00000116 => "\xcc",
     0x00000117 => "\xec",
     0x00000118 => "\xca",
     0x00000119 => "\xea",
     0x00000122 => "\xab",
     0x00000123 => "\xbb",
     0x00000128 => "\xa5",
     0x00000129 => "\xb5",
     0x0000012a => "\xcf",
     0x0000012b => "\xef",
     0x0000012e => "\xc7",
     0x0000012f => "\xe7",
     0x00000136 => "\xd3",
     0x00000137 => "\xf3",
     0x00000138 => "\xa2",
     0x0000013b => "\xa6",
     0x0000013c => "\xb6",
     0x00000145 => "\xd1",
     0x00000146 => "\xf1",
     0x0000014a => "\xbd",
     0x0000014b => "\xbf",
     0x0000014c => "\xd2",
     0x0000014d => "\xf2",
     0x00000156 => "\xa3",
     0x00000157 => "\xb3",
     0x00000160 => "\xa9",
     0x00000161 => "\xb9",
     0x00000166 => "\xac",
     0x00000167 => "\xbc",
     0x00000168 => "\xdd",
     0x00000169 => "\xfd",
     0x0000016a => "\xde",
     0x0000016b => "\xfe",
     0x00000172 => "\xd9",
     0x00000173 => "\xf9",
     0x0000017d => "\xae",
     0x0000017e => "\xbe",
     0x000002c7 => "\xb7",
     0x000002d9 => "\xff",
     0x000002db => "\xb2",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_5.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_5;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x0401,
     0x0402,
     0x0403,
     0x0404,
     0x0405,
     0x0406,
     0x0407,
     0x0408,
     0x0409,
     0x040a,
     0x040b,
     0x040c,
     0x00ad,
     0x040e,
     0x040f,
     0x0410,
     0x0411,
     0x0412,
     0x0413,
     0x0414,
     0x0415,
     0x0416,
     0x0417,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0424,
     0x0425,
     0x0426,
     0x0427,
     0x0428,
     0x0429,
     0x042a,
     0x042b,
     0x042c,
     0x042d,
     0x042e,
     0x042f,
     0x0430,
     0x0431,
     0x0432,
     0x0433,
     0x0434,
     0x0435,
     0x0436,
     0x0437,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0444,
     0x0445,
     0x0446,
     0x0447,
     0x0448,
     0x0449,
     0x044a,
     0x044b,
     0x044c,
     0x044d,
     0x044e,
     0x044f,
     0x2116,
     0x0451,
     0x0452,
     0x0453,
     0x0454,
     0x0455,
     0x0456,
     0x0457,
     0x0458,
     0x0459,
     0x045a,
     0x045b,
     0x045c,
     0x00a7,
     0x045e,
     0x045f,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xd0\x81",
     "\xd0\x82",
     "\xd0\x83",
     "\xd0\x84",
     "\xd0\x85",
     "\xd0\x86",
     "\xd0\x87",
     "\xd0\x88",
     "\xd0\x89",
     "\xd0\x8a",
     "\xd0\x8b",
     "\xd0\x8c",
     "\xc2\xad",
     "\xd0\x8e",
     "\xd0\x8f",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\x92",
     "\xd0\x93",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\x96",
     "\xd0\x97",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\xa4",
     "\xd0\xa5",
     "\xd0\xa6",
     "\xd0\xa7",
     "\xd0\xa8",
     "\xd0\xa9",
     "\xd0\xaa",
     "\xd0\xab",
     "\xd0\xac",
     "\xd0\xad",
     "\xd0\xae",
     "\xd0\xaf",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd0\xb2",
     "\xd0\xb3",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd0\xb6",
     "\xd0\xb7",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd1\x84",
     "\xd1\x85",
     "\xd1\x86",
     "\xd1\x87",
     "\xd1\x88",
     "\xd1\x89",
     "\xd1\x8a",
     "\xd1\x8b",
     "\xd1\x8c",
     "\xd1\x8d",
     "\xd1\x8e",
     "\xd1\x8f",
     "\xe2\x84\x96",
     "\xd1\x91",
     "\xd1\x92",
     "\xd1\x93",
     "\xd1\x94",
     "\xd1\x95",
     "\xd1\x96",
     "\xd1\x97",
     "\xd1\x98",
     "\xd1\x99",
     "\xd1\x9a",
     "\xd1\x9b",
     "\xd1\x9c",
     "\xc2\xa7",
     "\xd1\x9e",
     "\xd1\x9f",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a7 => "\xfd",
     0x000000ad => "\xad",
     0x00000401 => "\xa1",
     0x00000402 => "\xa2",
     0x00000403 => "\xa3",
     0x00000404 => "\xa4",
     0x00000405 => "\xa5",
     0x00000406 => "\xa6",
     0x00000407 => "\xa7",
     0x00000408 => "\xa8",
     0x00000409 => "\xa9",
     0x0000040a => "\xaa",
     0x0000040b => "\xab",
     0x0000040c => "\xac",
     0x0000040e => "\xae",
     0x0000040f => "\xaf",
     0x00000410 => "\xb0",
     0x00000411 => "\xb1",
     0x00000412 => "\xb2",
     0x00000413 => "\xb3",
     0x00000414 => "\xb4",
     0x00000415 => "\xb5",
     0x00000416 => "\xb6",
     0x00000417 => "\xb7",
     0x00000418 => "\xb8",
     0x00000419 => "\xb9",
     0x0000041a => "\xba",
     0x0000041b => "\xbb",
     0x0000041c => "\xbc",
     0x0000041d => "\xbd",
     0x0000041e => "\xbe",
     0x0000041f => "\xbf",
     0x00000420 => "\xc0",
     0x00000421 => "\xc1",
     0x00000422 => "\xc2",
     0x00000423 => "\xc3",
     0x00000424 => "\xc4",
     0x00000425 => "\xc5",
     0x00000426 => "\xc6",
     0x00000427 => "\xc7",
     0x00000428 => "\xc8",
     0x00000429 => "\xc9",
     0x0000042a => "\xca",
     0x0000042b => "\xcb",
     0x0000042c => "\xcc",
     0x0000042d => "\xcd",
     0x0000042e => "\xce",
     0x0000042f => "\xcf",
     0x00000430 => "\xd0",
     0x00000431 => "\xd1",
     0x00000432 => "\xd2",
     0x00000433 => "\xd3",
     0x00000434 => "\xd4",
     0x00000435 => "\xd5",
     0x00000436 => "\xd6",
     0x00000437 => "\xd7",
     0x00000438 => "\xd8",
     0x00000439 => "\xd9",
     0x0000043a => "\xda",
     0x0000043b => "\xdb",
     0x0000043c => "\xdc",
     0x0000043d => "\xdd",
     0x0000043e => "\xde",
     0x0000043f => "\xdf",
     0x00000440 => "\xe0",
     0x00000441 => "\xe1",
     0x00000442 => "\xe2",
     0x00000443 => "\xe3",
     0x00000444 => "\xe4",
     0x00000445 => "\xe5",
     0x00000446 => "\xe6",
     0x00000447 => "\xe7",
     0x00000448 => "\xe8",
     0x00000449 => "\xe9",
     0x0000044a => "\xea",
     0x0000044b => "\xeb",
     0x0000044c => "\xec",
     0x0000044d => "\xed",
     0x0000044e => "\xee",
     0x0000044f => "\xef",
     0x00000451 => "\xf1",
     0x00000452 => "\xf2",
     0x00000453 => "\xf3",
     0x00000454 => "\xf4",
     0x00000455 => "\xf5",
     0x00000456 => "\xf6",
     0x00000457 => "\xf7",
     0x00000458 => "\xf8",
     0x00000459 => "\xf9",
     0x0000045a => "\xfa",
     0x0000045b => "\xfb",
     0x0000045c => "\xfc",
     0x0000045e => "\xfe",
     0x0000045f => "\xff",
     0x00002116 => "\xf0",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_6.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_6;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a4,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x060c,
     0x00ad,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x061b,
     0xfffd,
     0xfffd,
     0xfffd,
     0x061f,
     0xfffd,
     0x0621,
     0x0622,
     0x0623,
     0x0624,
     0x0625,
     0x0626,
     0x0627,
     0x0628,
     0x0629,
     0x062a,
     0x062b,
     0x062c,
     0x062d,
     0x062e,
     0x062f,
     0x0630,
     0x0631,
     0x0632,
     0x0633,
     0x0634,
     0x0635,
     0x0636,
     0x0637,
     0x0638,
     0x0639,
     0x063a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0640,
     0x0641,
     0x0642,
     0x0643,
     0x0644,
     0x0645,
     0x0646,
     0x0647,
     0x0648,
     0x0649,
     0x064a,
     0x064b,
     0x064c,
     0x064d,
     0x064e,
     0x064f,
     0x0650,
     0x0651,
     0x0652,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa4",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd8\x8c",
     "\xc2\xad",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd8\x9b",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd8\x9f",
     "\xef\xbf\xbd",
     "\xd8\xa1",
     "\xd8\xa2",
     "\xd8\xa3",
     "\xd8\xa4",
     "\xd8\xa5",
     "\xd8\xa6",
     "\xd8\xa7",
     "\xd8\xa8",
     "\xd8\xa9",
     "\xd8\xaa",
     "\xd8\xab",
     "\xd8\xac",
     "\xd8\xad",
     "\xd8\xae",
     "\xd8\xaf",
     "\xd8\xb0",
     "\xd8\xb1",
     "\xd8\xb2",
     "\xd8\xb3",
     "\xd8\xb4",
     "\xd8\xb5",
     "\xd8\xb6",
     "\xd8\xb7",
     "\xd8\xb8",
     "\xd8\xb9",
     "\xd8\xba",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd9\x80",
     "\xd9\x81",
     "\xd9\x82",
     "\xd9\x83",
     "\xd9\x84",
     "\xd9\x85",
     "\xd9\x86",
     "\xd9\x87",
     "\xd9\x88",
     "\xd9\x89",
     "\xd9\x8a",
     "\xd9\x8b",
     "\xd9\x8c",
     "\xd9\x8d",
     "\xd9\x8e",
     "\xd9\x8f",
     "\xd9\x90",
     "\xd9\x91",
     "\xd9\x92",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a4 => "\xa4",
     0x000000ad => "\xad",
     0x0000060c => "\xac",
     0x0000061b => "\xbb",
     0x0000061f => "\xbf",
     0x00000621 => "\xc1",
     0x00000622 => "\xc2",
     0x00000623 => "\xc3",
     0x00000624 => "\xc4",
     0x00000625 => "\xc5",
     0x00000626 => "\xc6",
     0x00000627 => "\xc7",
     0x00000628 => "\xc8",
     0x00000629 => "\xc9",
     0x0000062a => "\xca",
     0x0000062b => "\xcb",
     0x0000062c => "\xcc",
     0x0000062d => "\xcd",
     0x0000062e => "\xce",
     0x0000062f => "\xcf",
     0x00000630 => "\xd0",
     0x00000631 => "\xd1",
     0x00000632 => "\xd2",
     0x00000633 => "\xd3",
     0x00000634 => "\xd4",
     0x00000635 => "\xd5",
     0x00000636 => "\xd6",
     0x00000637 => "\xd7",
     0x00000638 => "\xd8",
     0x00000639 => "\xd9",
     0x0000063a => "\xda",
     0x00000640 => "\xe0",
     0x00000641 => "\xe1",
     0x00000642 => "\xe2",
     0x00000643 => "\xe3",
     0x00000644 => "\xe4",
     0x00000645 => "\xe5",
     0x00000646 => "\xe6",
     0x00000647 => "\xe7",
     0x00000648 => "\xe8",
     0x00000649 => "\xe9",
     0x0000064a => "\xea",
     0x0000064b => "\xeb",
     0x0000064c => "\xec",
     0x0000064d => "\xed",
     0x0000064e => "\xee",
     0x0000064f => "\xef",
     0x00000650 => "\xf0",
     0x00000651 => "\xf1",
     0x00000652 => "\xf2",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_7.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_7;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x2018,
     0x2019,
     0x00a3,
     0xfffd,
     0xfffd,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0xfffd,
     0x00ab,
     0x00ac,
     0x00ad,
     0xfffd,
     0x2015,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x0384,
     0x0385,
     0x0386,
     0x00b7,
     0x0388,
     0x0389,
     0x038a,
     0x00bb,
     0x038c,
     0x00bd,
     0x038e,
     0x038f,
     0x0390,
     0x0391,
     0x0392,
     0x0393,
     0x0394,
     0x0395,
     0x0396,
     0x0397,
     0x0398,
     0x0399,
     0x039a,
     0x039b,
     0x039c,
     0x039d,
     0x039e,
     0x039f,
     0x03a0,
     0x03a1,
     0xfffd,
     0x03a3,
     0x03a4,
     0x03a5,
     0x03a6,
     0x03a7,
     0x03a8,
     0x03a9,
     0x03aa,
     0x03ab,
     0x03ac,
     0x03ad,
     0x03ae,
     0x03af,
     0x03b0,
     0x03b1,
     0x03b2,
     0x03b3,
     0x03b4,
     0x03b5,
     0x03b6,
     0x03b7,
     0x03b8,
     0x03b9,
     0x03ba,
     0x03bb,
     0x03bc,
     0x03bd,
     0x03be,
     0x03bf,
     0x03c0,
     0x03c1,
     0x03c2,
     0x03c3,
     0x03c4,
     0x03c5,
     0x03c6,
     0x03c7,
     0x03c8,
     0x03c9,
     0x03ca,
     0x03cb,
     0x03cc,
     0x03cd,
     0x03ce,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc2\xa3",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xef\xbf\xbd",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xef\xbf\xbd",
     "\xe2\x80\x95",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xce\x84",
     "\xce\x85",
     "\xce\x86",
     "\xc2\xb7",
     "\xce\x88",
     "\xce\x89",
     "\xce\x8a",
     "\xc2\xbb",
     "\xce\x8c",
     "\xc2\xbd",
     "\xce\x8e",
     "\xce\x8f",
     "\xce\x90",
     "\xce\x91",
     "\xce\x92",
     "\xce\x93",
     "\xce\x94",
     "\xce\x95",
     "\xce\x96",
     "\xce\x97",
     "\xce\x98",
     "\xce\x99",
     "\xce\x9a",
     "\xce\x9b",
     "\xce\x9c",
     "\xce\x9d",
     "\xce\x9e",
     "\xce\x9f",
     "\xce\xa0",
     "\xce\xa1",
     "\xef\xbf\xbd",
     "\xce\xa3",
     "\xce\xa4",
     "\xce\xa5",
     "\xce\xa6",
     "\xce\xa7",
     "\xce\xa8",
     "\xce\xa9",
     "\xce\xaa",
     "\xce\xab",
     "\xce\xac",
     "\xce\xad",
     "\xce\xae",
     "\xce\xaf",
     "\xce\xb0",
     "\xce\xb1",
     "\xce\xb2",
     "\xce\xb3",
     "\xce\xb4",
     "\xce\xb5",
     "\xce\xb6",
     "\xce\xb7",
     "\xce\xb8",
     "\xce\xb9",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xce\xbd",
     "\xce\xbe",
     "\xce\xbf",
     "\xcf\x80",
     "\xcf\x81",
     "\xcf\x82",
     "\xcf\x83",
     "\xcf\x84",
     "\xcf\x85",
     "\xcf\x86",
     "\xcf\x87",
     "\xcf\x88",
     "\xcf\x89",
     "\xcf\x8a",
     "\xcf\x8b",
     "\xcf\x8c",
     "\xcf\x8d",
     "\xcf\x8e",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a3 => "\xa3",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b7 => "\xb7",
     0x000000bb => "\xbb",
     0x000000bd => "\xbd",
     0x00000384 => "\xb4",
     0x00000385 => "\xb5",
     0x00000386 => "\xb6",
     0x00000388 => "\xb8",
     0x00000389 => "\xb9",
     0x0000038a => "\xba",
     0x0000038c => "\xbc",
     0x0000038e => "\xbe",
     0x0000038f => "\xbf",
     0x00000390 => "\xc0",
     0x00000391 => "\xc1",
     0x00000392 => "\xc2",
     0x00000393 => "\xc3",
     0x00000394 => "\xc4",
     0x00000395 => "\xc5",
     0x00000396 => "\xc6",
     0x00000397 => "\xc7",
     0x00000398 => "\xc8",
     0x00000399 => "\xc9",
     0x0000039a => "\xca",
     0x0000039b => "\xcb",
     0x0000039c => "\xcc",
     0x0000039d => "\xcd",
     0x0000039e => "\xce",
     0x0000039f => "\xcf",
     0x000003a0 => "\xd0",
     0x000003a1 => "\xd1",
     0x000003a3 => "\xd3",
     0x000003a4 => "\xd4",
     0x000003a5 => "\xd5",
     0x000003a6 => "\xd6",
     0x000003a7 => "\xd7",
     0x000003a8 => "\xd8",
     0x000003a9 => "\xd9",
     0x000003aa => "\xda",
     0x000003ab => "\xdb",
     0x000003ac => "\xdc",
     0x000003ad => "\xdd",
     0x000003ae => "\xde",
     0x000003af => "\xdf",
     0x000003b0 => "\xe0",
     0x000003b1 => "\xe1",
     0x000003b2 => "\xe2",
     0x000003b3 => "\xe3",
     0x000003b4 => "\xe4",
     0x000003b5 => "\xe5",
     0x000003b6 => "\xe6",
     0x000003b7 => "\xe7",
     0x000003b8 => "\xe8",
     0x000003b9 => "\xe9",
     0x000003ba => "\xea",
     0x000003bb => "\xeb",
     0x000003bc => "\xec",
     0x000003bd => "\xed",
     0x000003be => "\xee",
     0x000003bf => "\xef",
     0x000003c0 => "\xf0",
     0x000003c1 => "\xf1",
     0x000003c2 => "\xf2",
     0x000003c3 => "\xf3",
     0x000003c4 => "\xf4",
     0x000003c5 => "\xf5",
     0x000003c6 => "\xf6",
     0x000003c7 => "\xf7",
     0x000003c8 => "\xf8",
     0x000003c9 => "\xf9",
     0x000003ca => "\xfa",
     0x000003cb => "\xfb",
     0x000003cc => "\xfc",
     0x000003cd => "\xfd",
     0x000003ce => "\xfe",
     0x00002015 => "\xaf",
     0x00002018 => "\xa1",
     0x00002019 => "\xa2",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_8.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_8;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0xfffd,
     0x00a2,
     0x00a3,
     0x00a4,
     0x00a5,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0x00d7,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x00af,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x00b4,
     0x00b5,
     0x00b6,
     0x00b7,
     0x00b8,
     0x00b9,
     0x00f7,
     0x00bb,
     0x00bc,
     0x00bd,
     0x00be,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x2017,
     0x05d0,
     0x05d1,
     0x05d2,
     0x05d3,
     0x05d4,
     0x05d5,
     0x05d6,
     0x05d7,
     0x05d8,
     0x05d9,
     0x05da,
     0x05db,
     0x05dc,
     0x05dd,
     0x05de,
     0x05df,
     0x05e0,
     0x05e1,
     0x05e2,
     0x05e3,
     0x05e4,
     0x05e5,
     0x05e6,
     0x05e7,
     0x05e8,
     0x05e9,
     0x05ea,
     0xfffd,
     0xfffd,
     0x200e,
     0x200f,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xef\xbf\xbd",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xc2\xa5",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xc3\x97",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc2\xaf",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc2\xb8",
     "\xc2\xb9",
     "\xc3\xb7",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\x97",
     "\xd7\x90",
     "\xd7\x91",
     "\xd7\x92",
     "\xd7\x93",
     "\xd7\x94",
     "\xd7\x95",
     "\xd7\x96",
     "\xd7\x97",
     "\xd7\x98",
     "\xd7\x99",
     "\xd7\x9a",
     "\xd7\x9b",
     "\xd7\x9c",
     "\xd7\x9d",
     "\xd7\x9e",
     "\xd7\x9f",
     "\xd7\xa0",
     "\xd7\xa1",
     "\xd7\xa2",
     "\xd7\xa3",
     "\xd7\xa4",
     "\xd7\xa5",
     "\xd7\xa6",
     "\xd7\xa7",
     "\xd7\xa8",
     "\xd7\xa9",
     "\xd7\xaa",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\x8e",
     "\xe2\x80\x8f",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a5 => "\xa5",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000af => "\xaf",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b8 => "\xb8",
     0x000000b9 => "\xb9",
     0x000000bb => "\xbb",
     0x000000bc => "\xbc",
     0x000000bd => "\xbd",
     0x000000be => "\xbe",
     0x000000d7 => "\xaa",
     0x000000f7 => "\xba",
     0x000005d0 => "\xe0",
     0x000005d1 => "\xe1",
     0x000005d2 => "\xe2",
     0x000005d3 => "\xe3",
     0x000005d4 => "\xe4",
     0x000005d5 => "\xe5",
     0x000005d6 => "\xe6",
     0x000005d7 => "\xe7",
     0x000005d8 => "\xe8",
     0x000005d9 => "\xe9",
     0x000005da => "\xea",
     0x000005db => "\xeb",
     0x000005dc => "\xec",
     0x000005dd => "\xed",
     0x000005de => "\xee",
     0x000005df => "\xef",
     0x000005e0 => "\xf0",
     0x000005e1 => "\xf1",
     0x000005e2 => "\xf2",
     0x000005e3 => "\xf3",
     0x000005e4 => "\xf4",
     0x000005e5 => "\xf5",
     0x000005e6 => "\xf6",
     0x000005e7 => "\xf7",
     0x000005e8 => "\xf8",
     0x000005e9 => "\xf9",
     0x000005ea => "\xfa",
     0x0000200e => "\xfd",
     0x0000200f => "\xfe",
     0x00002017 => "\xdf",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/ISO_8859_9.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::ISO_8859_9;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0080,
     0x0081,
     0x0082,
     0x0083,
     0x0084,
     0x0085,
     0x0086,
     0x0087,
     0x0088,
     0x0089,
     0x008a,
     0x008b,
     0x008c,
     0x008d,
     0x008e,
     0x008f,
     0x0090,
     0x0091,
     0x0092,
     0x0093,
     0x0094,
     0x0095,
     0x0096,
     0x0097,
     0x0098,
     0x0099,
     0x009a,
     0x009b,
     0x009c,
     0x009d,
     0x009e,
     0x009f,
     0x00a0,
     0x00a1,
     0x00a2,
     0x00a3,
     0x00a4,
     0x00a5,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0x00aa,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x00af,
     0x00b0,
     0x00b1,
     0x00b2,
     0x00b3,
     0x00b4,
     0x00b5,
     0x00b6,
     0x00b7,
     0x00b8,
     0x00b9,
     0x00ba,
     0x00bb,
     0x00bc,
     0x00bd,
     0x00be,
     0x00bf,
     0x00c0,
     0x00c1,
     0x00c2,
     0x00c3,
     0x00c4,
     0x00c5,
     0x00c6,
     0x00c7,
     0x00c8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00cc,
     0x00cd,
     0x00ce,
     0x00cf,
     0x011e,
     0x00d1,
     0x00d2,
     0x00d3,
     0x00d4,
     0x00d5,
     0x00d6,
     0x00d7,
     0x00d8,
     0x00d9,
     0x00da,
     0x00db,
     0x00dc,
     0x0130,
     0x015e,
     0x00df,
     0x00e0,
     0x00e1,
     0x00e2,
     0x00e3,
     0x00e4,
     0x00e5,
     0x00e6,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0x011f,
     0x00f1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x00f7,
     0x00f8,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x0131,
     0x015f,
     0x00ff,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\x80",
     "\xc2\x81",
     "\xc2\x82",
     "\xc2\x83",
     "\xc2\x84",
     "\xc2\x85",
     "\xc2\x86",
     "\xc2\x87",
     "\xc2\x88",
     "\xc2\x89",
     "\xc2\x8a",
     "\xc2\x8b",
     "\xc2\x8c",
     "\xc2\x8d",
     "\xc2\x8e",
     "\xc2\x8f",
     "\xc2\x90",
     "\xc2\x91",
     "\xc2\x92",
     "\xc2\x93",
     "\xc2\x94",
     "\xc2\x95",
     "\xc2\x96",
     "\xc2\x97",
     "\xc2\x98",
     "\xc2\x99",
     "\xc2\x9a",
     "\xc2\x9b",
     "\xc2\x9c",
     "\xc2\x9d",
     "\xc2\x9e",
     "\xc2\x9f",
     "\xc2\xa0",
     "\xc2\xa1",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xc2\xa5",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xc2\xaa",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc2\xaf",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xc2\xb3",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc2\xb8",
     "\xc2\xb9",
     "\xc2\xba",
     "\xc2\xbb",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc2\xbf",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x86",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc4\x9e",
     "\xc3\x91",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xc3\x97",
     "\xc3\x98",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc4\xb0",
     "\xc5\x9e",
     "\xc3\x9f",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc4\x9f",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc3\xb8",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc4\xb1",
     "\xc5\x9f",
     "\xc3\xbf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000080 => "\x80",
     0x00000081 => "\x81",
     0x00000082 => "\x82",
     0x00000083 => "\x83",
     0x00000084 => "\x84",
     0x00000085 => "\x85",
     0x00000086 => "\x86",
     0x00000087 => "\x87",
     0x00000088 => "\x88",
     0x00000089 => "\x89",
     0x0000008a => "\x8a",
     0x0000008b => "\x8b",
     0x0000008c => "\x8c",
     0x0000008d => "\x8d",
     0x0000008e => "\x8e",
     0x0000008f => "\x8f",
     0x00000090 => "\x90",
     0x00000091 => "\x91",
     0x00000092 => "\x92",
     0x00000093 => "\x93",
     0x00000094 => "\x94",
     0x00000095 => "\x95",
     0x00000096 => "\x96",
     0x00000097 => "\x97",
     0x00000098 => "\x98",
     0x00000099 => "\x99",
     0x0000009a => "\x9a",
     0x0000009b => "\x9b",
     0x0000009c => "\x9c",
     0x0000009d => "\x9d",
     0x0000009e => "\x9e",
     0x0000009f => "\x9f",
     0x000000a0 => "\xa0",
     0x000000a1 => "\xa1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a5 => "\xa5",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000aa => "\xaa",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000af => "\xaf",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b3 => "\xb3",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000b8 => "\xb8",
     0x000000b9 => "\xb9",
     0x000000ba => "\xba",
     0x000000bb => "\xbb",
     0x000000bc => "\xbc",
     0x000000bd => "\xbd",
     0x000000be => "\xbe",
     0x000000bf => "\xbf",
     0x000000c0 => "\xc0",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c3 => "\xc3",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xc6",
     0x000000c7 => "\xc7",
     0x000000c8 => "\xc8",
     0x000000c9 => "\xc9",
     0x000000ca => "\xca",
     0x000000cb => "\xcb",
     0x000000cc => "\xcc",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000cf => "\xcf",
     0x000000d1 => "\xd1",
     0x000000d2 => "\xd2",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000d8 => "\xd8",
     0x000000d9 => "\xd9",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000df => "\xdf",
     0x000000e0 => "\xe0",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e3 => "\xe3",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xe6",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f1 => "\xf1",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f8 => "\xf8",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000ff => "\xff",
     0x0000011e => "\xd0",
     0x0000011f => "\xf0",
     0x00000130 => "\xdd",
     0x00000131 => "\xfd",
     0x0000015e => "\xde",
     0x0000015f => "\xfe",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/KOI8_R.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::KOI8_R;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x2500,
     0x2502,
     0x250c,
     0x2510,
     0x2514,
     0x2518,
     0x251c,
     0x2524,
     0x252c,
     0x2534,
     0x253c,
     0x2580,
     0x2584,
     0x2588,
     0x258c,
     0x2590,
     0x2591,
     0x2592,
     0x2593,
     0x2320,
     0x25a0,
     0x2219,
     0x221a,
     0x2248,
     0x2264,
     0x2265,
     0x00a0,
     0x2321,
     0x00b0,
     0x00b2,
     0x00b7,
     0x00f7,
     0x2550,
     0x2551,
     0x2552,
     0x0451,
     0x2553,
     0x2554,
     0x2555,
     0x2556,
     0x2557,
     0x2558,
     0x2559,
     0x255a,
     0x255b,
     0x255c,
     0x255d,
     0x255e,
     0x255f,
     0x2560,
     0x2561,
     0x0401,
     0x2562,
     0x2563,
     0x2564,
     0x2565,
     0x2566,
     0x2567,
     0x2568,
     0x2569,
     0x256a,
     0x256b,
     0x256c,
     0x00a9,
     0x044e,
     0x0430,
     0x0431,
     0x0446,
     0x0434,
     0x0435,
     0x0444,
     0x0433,
     0x0445,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x044f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0436,
     0x0432,
     0x044c,
     0x044b,
     0x0437,
     0x0448,
     0x044d,
     0x0449,
     0x0447,
     0x044a,
     0x042e,
     0x0410,
     0x0411,
     0x0426,
     0x0414,
     0x0415,
     0x0424,
     0x0413,
     0x0425,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x042f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0416,
     0x0412,
     0x042c,
     0x042b,
     0x0417,
     0x0428,
     0x042d,
     0x0429,
     0x0427,
     0x042a,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe2\x94\x80",
     "\xe2\x94\x82",
     "\xe2\x94\x8c",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\x98",
     "\xe2\x94\x9c",
     "\xe2\x94\xa4",
     "\xe2\x94\xac",
     "\xe2\x94\xb4",
     "\xe2\x94\xbc",
     "\xe2\x96\x80",
     "\xe2\x96\x84",
     "\xe2\x96\x88",
     "\xe2\x96\x8c",
     "\xe2\x96\x90",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x8c\xa0",
     "\xe2\x96\xa0",
     "\xe2\x88\x99",
     "\xe2\x88\x9a",
     "\xe2\x89\x88",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xc2\xa0",
     "\xe2\x8c\xa1",
     "\xc2\xb0",
     "\xc2\xb2",
     "\xc2\xb7",
     "\xc3\xb7",
     "\xe2\x95\x90",
     "\xe2\x95\x91",
     "\xe2\x95\x92",
     "\xd1\x91",
     "\xe2\x95\x93",
     "\xe2\x95\x94",
     "\xe2\x95\x95",
     "\xe2\x95\x96",
     "\xe2\x95\x97",
     "\xe2\x95\x98",
     "\xe2\x95\x99",
     "\xe2\x95\x9a",
     "\xe2\x95\x9b",
     "\xe2\x95\x9c",
     "\xe2\x95\x9d",
     "\xe2\x95\x9e",
     "\xe2\x95\x9f",
     "\xe2\x95\xa0",
     "\xe2\x95\xa1",
     "\xd0\x81",
     "\xe2\x95\xa2",
     "\xe2\x95\xa3",
     "\xe2\x95\xa4",
     "\xe2\x95\xa5",
     "\xe2\x95\xa6",
     "\xe2\x95\xa7",
     "\xe2\x95\xa8",
     "\xe2\x95\xa9",
     "\xe2\x95\xaa",
     "\xe2\x95\xab",
     "\xe2\x95\xac",
     "\xc2\xa9",
     "\xd1\x8e",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd1\x86",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd1\x84",
     "\xd0\xb3",
     "\xd1\x85",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x8f",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd0\xb6",
     "\xd0\xb2",
     "\xd1\x8c",
     "\xd1\x8b",
     "\xd0\xb7",
     "\xd1\x88",
     "\xd1\x8d",
     "\xd1\x89",
     "\xd1\x87",
     "\xd1\x8a",
     "\xd0\xae",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\xa6",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\xa4",
     "\xd0\x93",
     "\xd0\xa5",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xaf",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\x96",
     "\xd0\x92",
     "\xd0\xac",
     "\xd0\xab",
     "\xd0\x97",
     "\xd0\xa8",
     "\xd0\xad",
     "\xd0\xa9",
     "\xd0\xa7",
     "\xd0\xaa",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\x9a",
     0x000000a9 => "\xbf",
     0x000000b0 => "\x9c",
     0x000000b2 => "\x9d",
     0x000000b7 => "\x9e",
     0x000000f7 => "\x9f",
     0x00000401 => "\xb3",
     0x00000410 => "\xe1",
     0x00000411 => "\xe2",
     0x00000412 => "\xf7",
     0x00000413 => "\xe7",
     0x00000414 => "\xe4",
     0x00000415 => "\xe5",
     0x00000416 => "\xf6",
     0x00000417 => "\xfa",
     0x00000418 => "\xe9",
     0x00000419 => "\xea",
     0x0000041a => "\xeb",
     0x0000041b => "\xec",
     0x0000041c => "\xed",
     0x0000041d => "\xee",
     0x0000041e => "\xef",
     0x0000041f => "\xf0",
     0x00000420 => "\xf2",
     0x00000421 => "\xf3",
     0x00000422 => "\xf4",
     0x00000423 => "\xf5",
     0x00000424 => "\xe6",
     0x00000425 => "\xe8",
     0x00000426 => "\xe3",
     0x00000427 => "\xfe",
     0x00000428 => "\xfb",
     0x00000429 => "\xfd",
     0x0000042a => "\xff",
     0x0000042b => "\xf9",
     0x0000042c => "\xf8",
     0x0000042d => "\xfc",
     0x0000042e => "\xe0",
     0x0000042f => "\xf1",
     0x00000430 => "\xc1",
     0x00000431 => "\xc2",
     0x00000432 => "\xd7",
     0x00000433 => "\xc7",
     0x00000434 => "\xc4",
     0x00000435 => "\xc5",
     0x00000436 => "\xd6",
     0x00000437 => "\xda",
     0x00000438 => "\xc9",
     0x00000439 => "\xca",
     0x0000043a => "\xcb",
     0x0000043b => "\xcc",
     0x0000043c => "\xcd",
     0x0000043d => "\xce",
     0x0000043e => "\xcf",
     0x0000043f => "\xd0",
     0x00000440 => "\xd2",
     0x00000441 => "\xd3",
     0x00000442 => "\xd4",
     0x00000443 => "\xd5",
     0x00000444 => "\xc6",
     0x00000445 => "\xc8",
     0x00000446 => "\xc3",
     0x00000447 => "\xde",
     0x00000448 => "\xdb",
     0x00000449 => "\xdd",
     0x0000044a => "\xdf",
     0x0000044b => "\xd9",
     0x0000044c => "\xd8",
     0x0000044d => "\xdc",
     0x0000044e => "\xc0",
     0x0000044f => "\xd1",
     0x00000451 => "\xa3",
     0x00002219 => "\x95",
     0x0000221a => "\x96",
     0x00002248 => "\x97",
     0x00002264 => "\x98",
     0x00002265 => "\x99",
     0x00002320 => "\x93",
     0x00002321 => "\x9b",
     0x00002500 => "\x80",
     0x00002502 => "\x81",
     0x0000250c => "\x82",
     0x00002510 => "\x83",
     0x00002514 => "\x84",
     0x00002518 => "\x85",
     0x0000251c => "\x86",
     0x00002524 => "\x87",
     0x0000252c => "\x88",
     0x00002534 => "\x89",
     0x0000253c => "\x8a",
     0x00002550 => "\xa0",
     0x00002551 => "\xa1",
     0x00002552 => "\xa2",
     0x00002553 => "\xa4",
     0x00002554 => "\xa5",
     0x00002555 => "\xa6",
     0x00002556 => "\xa7",
     0x00002557 => "\xa8",
     0x00002558 => "\xa9",
     0x00002559 => "\xaa",
     0x0000255a => "\xab",
     0x0000255b => "\xac",
     0x0000255c => "\xad",
     0x0000255d => "\xae",
     0x0000255e => "\xaf",
     0x0000255f => "\xb0",
     0x00002560 => "\xb1",
     0x00002561 => "\xb2",
     0x00002562 => "\xb4",
     0x00002563 => "\xb5",
     0x00002564 => "\xb6",
     0x00002565 => "\xb7",
     0x00002566 => "\xb8",
     0x00002567 => "\xb9",
     0x00002568 => "\xba",
     0x00002569 => "\xbb",
     0x0000256a => "\xbc",
     0x0000256b => "\xbd",
     0x0000256c => "\xbe",
     0x00002580 => "\x8b",
     0x00002584 => "\x8c",
     0x00002588 => "\x8d",
     0x0000258c => "\x8e",
     0x00002590 => "\x8f",
     0x00002591 => "\x90",
     0x00002592 => "\x91",
     0x00002593 => "\x92",
     0x000025a0 => "\x94",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/KOI8_RU.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::KOI8_RU;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x2500,
     0x2502,
     0x250c,
     0x2510,
     0x2514,
     0x2518,
     0x251c,
     0x2524,
     0x252c,
     0x2534,
     0x253c,
     0x2580,
     0x2584,
     0x2588,
     0x258c,
     0x2590,
     0x2591,
     0x2592,
     0x2593,
     0x2320,
     0x25a0,
     0x2219,
     0x221a,
     0x2248,
     0x2264,
     0x2265,
     0x00a0,
     0x2321,
     0x00b0,
     0x00b2,
     0x00b7,
     0x00f7,
     0x2550,
     0x2551,
     0x2552,
     0x0451,
     0x0454,
     0x2554,
     0x0456,
     0x0457,
     0x2557,
     0x2558,
     0x2559,
     0x255a,
     0x255b,
     0x0491,
     0x045e,
     0x255e,
     0x255f,
     0x2560,
     0x2561,
     0x0401,
     0x0404,
     0x2563,
     0x0406,
     0x0407,
     0x2566,
     0x2567,
     0x2568,
     0x2569,
     0x256a,
     0x0490,
     0x040e,
     0x00a9,
     0x044e,
     0x0430,
     0x0431,
     0x0446,
     0x0434,
     0x0435,
     0x0444,
     0x0433,
     0x0445,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x044f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0436,
     0x0432,
     0x044c,
     0x044b,
     0x0437,
     0x0448,
     0x044d,
     0x0449,
     0x0447,
     0x044a,
     0x042e,
     0x0410,
     0x0411,
     0x0426,
     0x0414,
     0x0415,
     0x0424,
     0x0413,
     0x0425,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x042f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0416,
     0x0412,
     0x042c,
     0x042b,
     0x0417,
     0x0428,
     0x042d,
     0x0429,
     0x0427,
     0x042a,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe2\x94\x80",
     "\xe2\x94\x82",
     "\xe2\x94\x8c",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\x98",
     "\xe2\x94\x9c",
     "\xe2\x94\xa4",
     "\xe2\x94\xac",
     "\xe2\x94\xb4",
     "\xe2\x94\xbc",
     "\xe2\x96\x80",
     "\xe2\x96\x84",
     "\xe2\x96\x88",
     "\xe2\x96\x8c",
     "\xe2\x96\x90",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x8c\xa0",
     "\xe2\x96\xa0",
     "\xe2\x88\x99",
     "\xe2\x88\x9a",
     "\xe2\x89\x88",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xc2\xa0",
     "\xe2\x8c\xa1",
     "\xc2\xb0",
     "\xc2\xb2",
     "\xc2\xb7",
     "\xc3\xb7",
     "\xe2\x95\x90",
     "\xe2\x95\x91",
     "\xe2\x95\x92",
     "\xd1\x91",
     "\xd1\x94",
     "\xe2\x95\x94",
     "\xd1\x96",
     "\xd1\x97",
     "\xe2\x95\x97",
     "\xe2\x95\x98",
     "\xe2\x95\x99",
     "\xe2\x95\x9a",
     "\xe2\x95\x9b",
     "\xd2\x91",
     "\xd1\x9e",
     "\xe2\x95\x9e",
     "\xe2\x95\x9f",
     "\xe2\x95\xa0",
     "\xe2\x95\xa1",
     "\xd0\x81",
     "\xd0\x84",
     "\xe2\x95\xa3",
     "\xd0\x86",
     "\xd0\x87",
     "\xe2\x95\xa6",
     "\xe2\x95\xa7",
     "\xe2\x95\xa8",
     "\xe2\x95\xa9",
     "\xe2\x95\xaa",
     "\xd2\x90",
     "\xd0\x8e",
     "\xc2\xa9",
     "\xd1\x8e",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd1\x86",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd1\x84",
     "\xd0\xb3",
     "\xd1\x85",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x8f",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd0\xb6",
     "\xd0\xb2",
     "\xd1\x8c",
     "\xd1\x8b",
     "\xd0\xb7",
     "\xd1\x88",
     "\xd1\x8d",
     "\xd1\x89",
     "\xd1\x87",
     "\xd1\x8a",
     "\xd0\xae",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\xa6",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\xa4",
     "\xd0\x93",
     "\xd0\xa5",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xaf",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\x96",
     "\xd0\x92",
     "\xd0\xac",
     "\xd0\xab",
     "\xd0\x97",
     "\xd0\xa8",
     "\xd0\xad",
     "\xd0\xa9",
     "\xd0\xa7",
     "\xd0\xaa",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\x9a",
     0x000000a9 => "\xbf",
     0x000000b0 => "\x9c",
     0x000000b2 => "\x9d",
     0x000000b7 => "\x9e",
     0x000000f7 => "\x9f",
     0x00000401 => "\xb3",
     0x00000404 => "\xb4",
     0x00000406 => "\xb6",
     0x00000407 => "\xb7",
     0x0000040e => "\xbe",
     0x00000410 => "\xe1",
     0x00000411 => "\xe2",
     0x00000412 => "\xf7",
     0x00000413 => "\xe7",
     0x00000414 => "\xe4",
     0x00000415 => "\xe5",
     0x00000416 => "\xf6",
     0x00000417 => "\xfa",
     0x00000418 => "\xe9",
     0x00000419 => "\xea",
     0x0000041a => "\xeb",
     0x0000041b => "\xec",
     0x0000041c => "\xed",
     0x0000041d => "\xee",
     0x0000041e => "\xef",
     0x0000041f => "\xf0",
     0x00000420 => "\xf2",
     0x00000421 => "\xf3",
     0x00000422 => "\xf4",
     0x00000423 => "\xf5",
     0x00000424 => "\xe6",
     0x00000425 => "\xe8",
     0x00000426 => "\xe3",
     0x00000427 => "\xfe",
     0x00000428 => "\xfb",
     0x00000429 => "\xfd",
     0x0000042a => "\xff",
     0x0000042b => "\xf9",
     0x0000042c => "\xf8",
     0x0000042d => "\xfc",
     0x0000042e => "\xe0",
     0x0000042f => "\xf1",
     0x00000430 => "\xc1",
     0x00000431 => "\xc2",
     0x00000432 => "\xd7",
     0x00000433 => "\xc7",
     0x00000434 => "\xc4",
     0x00000435 => "\xc5",
     0x00000436 => "\xd6",
     0x00000437 => "\xda",
     0x00000438 => "\xc9",
     0x00000439 => "\xca",
     0x0000043a => "\xcb",
     0x0000043b => "\xcc",
     0x0000043c => "\xcd",
     0x0000043d => "\xce",
     0x0000043e => "\xcf",
     0x0000043f => "\xd0",
     0x00000440 => "\xd2",
     0x00000441 => "\xd3",
     0x00000442 => "\xd4",
     0x00000443 => "\xd5",
     0x00000444 => "\xc6",
     0x00000445 => "\xc8",
     0x00000446 => "\xc3",
     0x00000447 => "\xde",
     0x00000448 => "\xdb",
     0x00000449 => "\xdd",
     0x0000044a => "\xdf",
     0x0000044b => "\xd9",
     0x0000044c => "\xd8",
     0x0000044d => "\xdc",
     0x0000044e => "\xc0",
     0x0000044f => "\xd1",
     0x00000451 => "\xa3",
     0x00000454 => "\xa4",
     0x00000456 => "\xa6",
     0x00000457 => "\xa7",
     0x0000045e => "\xae",
     0x00000490 => "\xbd",
     0x00000491 => "\xad",
     0x00002219 => "\x95",
     0x0000221a => "\x96",
     0x00002248 => "\x97",
     0x00002264 => "\x98",
     0x00002265 => "\x99",
     0x00002320 => "\x93",
     0x00002321 => "\x9b",
     0x00002500 => "\x80",
     0x00002502 => "\x81",
     0x0000250c => "\x82",
     0x00002510 => "\x83",
     0x00002514 => "\x84",
     0x00002518 => "\x85",
     0x0000251c => "\x86",
     0x00002524 => "\x87",
     0x0000252c => "\x88",
     0x00002534 => "\x89",
     0x0000253c => "\x8a",
     0x00002550 => "\xa0",
     0x00002551 => "\xa1",
     0x00002552 => "\xa2",
     0x00002554 => "\xa5",
     0x00002557 => "\xa8",
     0x00002558 => "\xa9",
     0x00002559 => "\xaa",
     0x0000255a => "\xab",
     0x0000255b => "\xac",
     0x0000255e => "\xaf",
     0x0000255f => "\xb0",
     0x00002560 => "\xb1",
     0x00002561 => "\xb2",
     0x00002563 => "\xb5",
     0x00002566 => "\xb8",
     0x00002567 => "\xb9",
     0x00002568 => "\xba",
     0x00002569 => "\xbb",
     0x0000256a => "\xbc",
     0x00002580 => "\x8b",
     0x00002584 => "\x8c",
     0x00002588 => "\x8d",
     0x0000258c => "\x8e",
     0x00002590 => "\x8f",
     0x00002591 => "\x90",
     0x00002592 => "\x91",
     0x00002593 => "\x92",
     0x000025a0 => "\x94",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/KOI8_T.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::KOI8_T;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x049b,
     0x0493,
     0x201a,
     0x0492,
     0x201e,
     0x2026,
     0x2020,
     0x2021,
     0xfffd,
     0x2030,
     0x04b3,
     0x2039,
     0x04b2,
     0x04b7,
     0x04b6,
     0xfffd,
     0x049a,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0xfffd,
     0x2122,
     0xfffd,
     0x203a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x04ef,
     0x04ee,
     0x0451,
     0x00a4,
     0x04e3,
     0x00a6,
     0x00a7,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0xfffd,
     0x00b0,
     0x00b1,
     0x00b2,
     0x0401,
     0xfffd,
     0x04e2,
     0x00b6,
     0x00b7,
     0xfffd,
     0x2116,
     0xfffd,
     0x00bb,
     0xfffd,
     0xfffd,
     0xfffd,
     0x00a9,
     0x044e,
     0x0430,
     0x0431,
     0x0446,
     0x0434,
     0x0435,
     0x0444,
     0x0433,
     0x0445,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x044f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0436,
     0x0432,
     0x044c,
     0x044b,
     0x0437,
     0x0448,
     0x044d,
     0x0449,
     0x0447,
     0x044a,
     0x042e,
     0x0410,
     0x0411,
     0x0426,
     0x0414,
     0x0415,
     0x0424,
     0x0413,
     0x0425,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x042f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0416,
     0x0412,
     0x042c,
     0x042b,
     0x0417,
     0x0428,
     0x042d,
     0x0429,
     0x0427,
     0x042a,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xd2\x9b",
     "\xd2\x93",
     "\xe2\x80\x9a",
     "\xd2\x92",
     "\xe2\x80\x9e",
     "\xe2\x80\xa6",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xef\xbf\xbd",
     "\xe2\x80\xb0",
     "\xd2\xb3",
     "\xe2\x80\xb9",
     "\xd2\xb2",
     "\xd2\xb7",
     "\xd2\xb6",
     "\xef\xbf\xbd",
     "\xd2\x9a",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xef\xbf\xbd",
     "\xe2\x84\xa2",
     "\xef\xbf\xbd",
     "\xe2\x80\xba",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd3\xaf",
     "\xd3\xae",
     "\xd1\x91",
     "\xc2\xa4",
     "\xd3\xa3",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xef\xbf\xbd",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc2\xb2",
     "\xd0\x81",
     "\xef\xbf\xbd",
     "\xd3\xa2",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xef\xbf\xbd",
     "\xe2\x84\x96",
     "\xef\xbf\xbd",
     "\xc2\xbb",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xa9",
     "\xd1\x8e",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd1\x86",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd1\x84",
     "\xd0\xb3",
     "\xd1\x85",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x8f",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd0\xb6",
     "\xd0\xb2",
     "\xd1\x8c",
     "\xd1\x8b",
     "\xd0\xb7",
     "\xd1\x88",
     "\xd1\x8d",
     "\xd1\x89",
     "\xd1\x87",
     "\xd1\x8a",
     "\xd0\xae",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\xa6",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\xa4",
     "\xd0\x93",
     "\xd0\xa5",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xaf",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\x96",
     "\xd0\x92",
     "\xd0\xac",
     "\xd0\xab",
     "\xd0\x97",
     "\xd0\xa8",
     "\xd0\xad",
     "\xd0\xa9",
     "\xd0\xa7",
     "\xd0\xaa",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a4 => "\xa4",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a9 => "\xbf",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b2 => "\xb2",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000bb => "\xbb",
     0x00000401 => "\xb3",
     0x00000410 => "\xe1",
     0x00000411 => "\xe2",
     0x00000412 => "\xf7",
     0x00000413 => "\xe7",
     0x00000414 => "\xe4",
     0x00000415 => "\xe5",
     0x00000416 => "\xf6",
     0x00000417 => "\xfa",
     0x00000418 => "\xe9",
     0x00000419 => "\xea",
     0x0000041a => "\xeb",
     0x0000041b => "\xec",
     0x0000041c => "\xed",
     0x0000041d => "\xee",
     0x0000041e => "\xef",
     0x0000041f => "\xf0",
     0x00000420 => "\xf2",
     0x00000421 => "\xf3",
     0x00000422 => "\xf4",
     0x00000423 => "\xf5",
     0x00000424 => "\xe6",
     0x00000425 => "\xe8",
     0x00000426 => "\xe3",
     0x00000427 => "\xfe",
     0x00000428 => "\xfb",
     0x00000429 => "\xfd",
     0x0000042a => "\xff",
     0x0000042b => "\xf9",
     0x0000042c => "\xf8",
     0x0000042d => "\xfc",
     0x0000042e => "\xe0",
     0x0000042f => "\xf1",
     0x00000430 => "\xc1",
     0x00000431 => "\xc2",
     0x00000432 => "\xd7",
     0x00000433 => "\xc7",
     0x00000434 => "\xc4",
     0x00000435 => "\xc5",
     0x00000436 => "\xd6",
     0x00000437 => "\xda",
     0x00000438 => "\xc9",
     0x00000439 => "\xca",
     0x0000043a => "\xcb",
     0x0000043b => "\xcc",
     0x0000043c => "\xcd",
     0x0000043d => "\xce",
     0x0000043e => "\xcf",
     0x0000043f => "\xd0",
     0x00000440 => "\xd2",
     0x00000441 => "\xd3",
     0x00000442 => "\xd4",
     0x00000443 => "\xd5",
     0x00000444 => "\xc6",
     0x00000445 => "\xc8",
     0x00000446 => "\xc3",
     0x00000447 => "\xde",
     0x00000448 => "\xdb",
     0x00000449 => "\xdd",
     0x0000044a => "\xdf",
     0x0000044b => "\xd9",
     0x0000044c => "\xd8",
     0x0000044d => "\xdc",
     0x0000044e => "\xc0",
     0x0000044f => "\xd1",
     0x00000451 => "\xa3",
     0x00000492 => "\x83",
     0x00000493 => "\x81",
     0x0000049a => "\x90",
     0x0000049b => "\x80",
     0x000004b2 => "\x8c",
     0x000004b3 => "\x8a",
     0x000004b6 => "\x8e",
     0x000004b7 => "\x8d",
     0x000004e2 => "\xb5",
     0x000004e3 => "\xa5",
     0x000004ee => "\xa2",
     0x000004ef => "\xa1",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201a => "\x82",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x0000201e => "\x84",
     0x00002020 => "\x86",
     0x00002021 => "\x87",
     0x00002022 => "\x95",
     0x00002026 => "\x85",
     0x00002030 => "\x89",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x00002116 => "\xb9",
     0x00002122 => "\x99",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/KOI8_U.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::KOI8_U;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x2500,
     0x2502,
     0x250c,
     0x2510,
     0x2514,
     0x2518,
     0x251c,
     0x2524,
     0x252c,
     0x2534,
     0x253c,
     0x2580,
     0x2584,
     0x2588,
     0x258c,
     0x2590,
     0x2591,
     0x2592,
     0x2593,
     0x2320,
     0x25a0,
     0x2219,
     0x221a,
     0x2248,
     0x2264,
     0x2265,
     0x00a0,
     0x2321,
     0x00b0,
     0x00b2,
     0x00b7,
     0x00f7,
     0x2550,
     0x2551,
     0x2552,
     0x0451,
     0x0454,
     0x2554,
     0x0456,
     0x0457,
     0x2557,
     0x2558,
     0x2559,
     0x255a,
     0x255b,
     0x0491,
     0x255d,
     0x255e,
     0x255f,
     0x2560,
     0x2561,
     0x0401,
     0x0404,
     0x2563,
     0x0406,
     0x0407,
     0x2566,
     0x2567,
     0x2568,
     0x2569,
     0x256a,
     0x0490,
     0x256c,
     0x00a9,
     0x044e,
     0x0430,
     0x0431,
     0x0446,
     0x0434,
     0x0435,
     0x0444,
     0x0433,
     0x0445,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x044f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0436,
     0x0432,
     0x044c,
     0x044b,
     0x0437,
     0x0448,
     0x044d,
     0x0449,
     0x0447,
     0x044a,
     0x042e,
     0x0410,
     0x0411,
     0x0426,
     0x0414,
     0x0415,
     0x0424,
     0x0413,
     0x0425,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x042f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0416,
     0x0412,
     0x042c,
     0x042b,
     0x0417,
     0x0428,
     0x042d,
     0x0429,
     0x0427,
     0x042a,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe2\x94\x80",
     "\xe2\x94\x82",
     "\xe2\x94\x8c",
     "\xe2\x94\x90",
     "\xe2\x94\x94",
     "\xe2\x94\x98",
     "\xe2\x94\x9c",
     "\xe2\x94\xa4",
     "\xe2\x94\xac",
     "\xe2\x94\xb4",
     "\xe2\x94\xbc",
     "\xe2\x96\x80",
     "\xe2\x96\x84",
     "\xe2\x96\x88",
     "\xe2\x96\x8c",
     "\xe2\x96\x90",
     "\xe2\x96\x91",
     "\xe2\x96\x92",
     "\xe2\x96\x93",
     "\xe2\x8c\xa0",
     "\xe2\x96\xa0",
     "\xe2\x88\x99",
     "\xe2\x88\x9a",
     "\xe2\x89\x88",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xc2\xa0",
     "\xe2\x8c\xa1",
     "\xc2\xb0",
     "\xc2\xb2",
     "\xc2\xb7",
     "\xc3\xb7",
     "\xe2\x95\x90",
     "\xe2\x95\x91",
     "\xe2\x95\x92",
     "\xd1\x91",
     "\xd1\x94",
     "\xe2\x95\x94",
     "\xd1\x96",
     "\xd1\x97",
     "\xe2\x95\x97",
     "\xe2\x95\x98",
     "\xe2\x95\x99",
     "\xe2\x95\x9a",
     "\xe2\x95\x9b",
     "\xd2\x91",
     "\xe2\x95\x9d",
     "\xe2\x95\x9e",
     "\xe2\x95\x9f",
     "\xe2\x95\xa0",
     "\xe2\x95\xa1",
     "\xd0\x81",
     "\xd0\x84",
     "\xe2\x95\xa3",
     "\xd0\x86",
     "\xd0\x87",
     "\xe2\x95\xa6",
     "\xe2\x95\xa7",
     "\xe2\x95\xa8",
     "\xe2\x95\xa9",
     "\xe2\x95\xaa",
     "\xd2\x90",
     "\xe2\x95\xac",
     "\xc2\xa9",
     "\xd1\x8e",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd1\x86",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd1\x84",
     "\xd0\xb3",
     "\xd1\x85",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x8f",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd0\xb6",
     "\xd0\xb2",
     "\xd1\x8c",
     "\xd1\x8b",
     "\xd0\xb7",
     "\xd1\x88",
     "\xd1\x8d",
     "\xd1\x89",
     "\xd1\x87",
     "\xd1\x8a",
     "\xd0\xae",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\xa6",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\xa4",
     "\xd0\x93",
     "\xd0\xa5",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xaf",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\x96",
     "\xd0\x92",
     "\xd0\xac",
     "\xd0\xab",
     "\xd0\x97",
     "\xd0\xa8",
     "\xd0\xad",
     "\xd0\xa9",
     "\xd0\xa7",
     "\xd0\xaa",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\x9a",
     0x000000a9 => "\xbf",
     0x000000b0 => "\x9c",
     0x000000b2 => "\x9d",
     0x000000b7 => "\x9e",
     0x000000f7 => "\x9f",
     0x00000401 => "\xb3",
     0x00000404 => "\xb4",
     0x00000406 => "\xb6",
     0x00000407 => "\xb7",
     0x00000410 => "\xe1",
     0x00000411 => "\xe2",
     0x00000412 => "\xf7",
     0x00000413 => "\xe7",
     0x00000414 => "\xe4",
     0x00000415 => "\xe5",
     0x00000416 => "\xf6",
     0x00000417 => "\xfa",
     0x00000418 => "\xe9",
     0x00000419 => "\xea",
     0x0000041a => "\xeb",
     0x0000041b => "\xec",
     0x0000041c => "\xed",
     0x0000041d => "\xee",
     0x0000041e => "\xef",
     0x0000041f => "\xf0",
     0x00000420 => "\xf2",
     0x00000421 => "\xf3",
     0x00000422 => "\xf4",
     0x00000423 => "\xf5",
     0x00000424 => "\xe6",
     0x00000425 => "\xe8",
     0x00000426 => "\xe3",
     0x00000427 => "\xfe",
     0x00000428 => "\xfb",
     0x00000429 => "\xfd",
     0x0000042a => "\xff",
     0x0000042b => "\xf9",
     0x0000042c => "\xf8",
     0x0000042d => "\xfc",
     0x0000042e => "\xe0",
     0x0000042f => "\xf1",
     0x00000430 => "\xc1",
     0x00000431 => "\xc2",
     0x00000432 => "\xd7",
     0x00000433 => "\xc7",
     0x00000434 => "\xc4",
     0x00000435 => "\xc5",
     0x00000436 => "\xd6",
     0x00000437 => "\xda",
     0x00000438 => "\xc9",
     0x00000439 => "\xca",
     0x0000043a => "\xcb",
     0x0000043b => "\xcc",
     0x0000043c => "\xcd",
     0x0000043d => "\xce",
     0x0000043e => "\xcf",
     0x0000043f => "\xd0",
     0x00000440 => "\xd2",
     0x00000441 => "\xd3",
     0x00000442 => "\xd4",
     0x00000443 => "\xd5",
     0x00000444 => "\xc6",
     0x00000445 => "\xc8",
     0x00000446 => "\xc3",
     0x00000447 => "\xde",
     0x00000448 => "\xdb",
     0x00000449 => "\xdd",
     0x0000044a => "\xdf",
     0x0000044b => "\xd9",
     0x0000044c => "\xd8",
     0x0000044d => "\xdc",
     0x0000044e => "\xc0",
     0x0000044f => "\xd1",
     0x00000451 => "\xa3",
     0x00000454 => "\xa4",
     0x00000456 => "\xa6",
     0x00000457 => "\xa7",
     0x00000490 => "\xbd",
     0x00000491 => "\xad",
     0x00002219 => "\x95",
     0x0000221a => "\x96",
     0x00002248 => "\x97",
     0x00002264 => "\x98",
     0x00002265 => "\x99",
     0x00002320 => "\x93",
     0x00002321 => "\x9b",
     0x00002500 => "\x80",
     0x00002502 => "\x81",
     0x0000250c => "\x82",
     0x00002510 => "\x83",
     0x00002514 => "\x84",
     0x00002518 => "\x85",
     0x0000251c => "\x86",
     0x00002524 => "\x87",
     0x0000252c => "\x88",
     0x00002534 => "\x89",
     0x0000253c => "\x8a",
     0x00002550 => "\xa0",
     0x00002551 => "\xa1",
     0x00002552 => "\xa2",
     0x00002554 => "\xa5",
     0x00002557 => "\xa8",
     0x00002558 => "\xa9",
     0x00002559 => "\xaa",
     0x0000255a => "\xab",
     0x0000255b => "\xac",
     0x0000255d => "\xae",
     0x0000255e => "\xaf",
     0x0000255f => "\xb0",
     0x00002560 => "\xb1",
     0x00002561 => "\xb2",
     0x00002563 => "\xb5",
     0x00002566 => "\xb8",
     0x00002567 => "\xb9",
     0x00002568 => "\xba",
     0x00002569 => "\xbb",
     0x0000256a => "\xbc",
     0x0000256c => "\xbe",
     0x00002580 => "\x8b",
     0x00002584 => "\x8c",
     0x00002588 => "\x8d",
     0x0000258c => "\x8e",
     0x00002590 => "\x8f",
     0x00002591 => "\x90",
     0x00002592 => "\x91",
     0x00002593 => "\x92",
     0x000025a0 => "\x94",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/KOI_8.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::KOI_8;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x044e,
     0x0430,
     0x0431,
     0x0446,
     0x0434,
     0x0435,
     0x0444,
     0x0433,
     0x0445,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x044f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0436,
     0x0432,
     0x044c,
     0x044b,
     0x0437,
     0x0448,
     0x044d,
     0x0449,
     0x0447,
     0x044a,
     0x042e,
     0x0410,
     0x0411,
     0x0426,
     0x0414,
     0x0415,
     0x0424,
     0x0413,
     0x0425,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x042f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0416,
     0x0412,
     0x042c,
     0x042b,
     0x0417,
     0x0428,
     0x042d,
     0x0429,
     0x0427,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd1\x8e",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd1\x86",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd1\x84",
     "\xd0\xb3",
     "\xd1\x85",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x8f",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd0\xb6",
     "\xd0\xb2",
     "\xd1\x8c",
     "\xd1\x8b",
     "\xd0\xb7",
     "\xd1\x88",
     "\xd1\x8d",
     "\xd1\x89",
     "\xd1\x87",
     "\xd1\x8a",
     "\xd0\xae",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\xa6",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\xa4",
     "\xd0\x93",
     "\xd0\xa5",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xaf",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\x96",
     "\xd0\x92",
     "\xd0\xac",
     "\xd0\xab",
     "\xd0\x97",
     "\xd0\xa8",
     "\xd0\xad",
     "\xd0\xa9",
     "\xd0\xa7",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000410 => "\xe1",
     0x00000411 => "\xe2",
     0x00000412 => "\xf7",
     0x00000413 => "\xe7",
     0x00000414 => "\xe4",
     0x00000415 => "\xe5",
     0x00000416 => "\xf6",
     0x00000417 => "\xfa",
     0x00000418 => "\xe9",
     0x00000419 => "\xea",
     0x0000041a => "\xeb",
     0x0000041b => "\xec",
     0x0000041c => "\xed",
     0x0000041d => "\xee",
     0x0000041e => "\xef",
     0x0000041f => "\xf0",
     0x00000420 => "\xf2",
     0x00000421 => "\xf3",
     0x00000422 => "\xf4",
     0x00000423 => "\xf5",
     0x00000424 => "\xe6",
     0x00000425 => "\xe8",
     0x00000426 => "\xe3",
     0x00000427 => "\xfe",
     0x00000428 => "\xfb",
     0x00000429 => "\xfd",
     0x0000042b => "\xf9",
     0x0000042c => "\xf8",
     0x0000042d => "\xfc",
     0x0000042e => "\xe0",
     0x0000042f => "\xf1",
     0x00000430 => "\xc1",
     0x00000431 => "\xc2",
     0x00000432 => "\xd7",
     0x00000433 => "\xc7",
     0x00000434 => "\xc4",
     0x00000435 => "\xc5",
     0x00000436 => "\xd6",
     0x00000437 => "\xda",
     0x00000438 => "\xc9",
     0x00000439 => "\xca",
     0x0000043a => "\xcb",
     0x0000043b => "\xcc",
     0x0000043c => "\xcd",
     0x0000043d => "\xce",
     0x0000043e => "\xcf",
     0x0000043f => "\xd0",
     0x00000440 => "\xd2",
     0x00000441 => "\xd3",
     0x00000442 => "\xd4",
     0x00000443 => "\xd5",
     0x00000444 => "\xc6",
     0x00000445 => "\xc8",
     0x00000446 => "\xc3",
     0x00000447 => "\xde",
     0x00000448 => "\xdb",
     0x00000449 => "\xdd",
     0x0000044a => "\xdf",
     0x0000044b => "\xd9",
     0x0000044c => "\xd8",
     0x0000044d => "\xdc",
     0x0000044e => "\xc0",
     0x0000044f => "\xd1",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/LATIN_GREEK.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::LATIN_GREEK;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x00a3,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0391,
     0x0392,
     0x03a8,
     0x0394,
     0x0395,
     0x03a6,
     0x0393,
     0x0397,
     0x0399,
     0x039e,
     0x039a,
     0x039b,
     0x039c,
     0x039d,
     0x039f,
     0x03a0,
     0xfffd,
     0x03a1,
     0x03a3,
     0x03a4,
     0x0398,
     0x03a9,
     0x00b7,
     0x03a7,
     0x03a5,
     0x0396,
     0x007b,
     0x007c,
     0x007d,
     0x00a8,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\xc2\xa3",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\xce\x91",
     "\xce\x92",
     "\xce\xa8",
     "\xce\x94",
     "\xce\x95",
     "\xce\xa6",
     "\xce\x93",
     "\xce\x97",
     "\xce\x99",
     "\xce\x9e",
     "\xce\x9a",
     "\xce\x9b",
     "\xce\x9c",
     "\xce\x9d",
     "\xce\x9f",
     "\xce\xa0",
     "\xef\xbf\xbd",
     "\xce\xa1",
     "\xce\xa3",
     "\xce\xa4",
     "\xce\x98",
     "\xce\xa9",
     "\xc2\xb7",
     "\xce\xa7",
     "\xce\xa5",
     "\xce\x96",
     "\x7b",
     "\x7c",
     "\x7d",
     "\xc2\xa8",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007f => "\x7f",
     0x000000a3 => "\x23",
     0x000000a8 => "\x7e",
     0x000000b7 => "\x77",
     0x00000391 => "\x61",
     0x00000392 => "\x62",
     0x00000393 => "\x67",
     0x00000394 => "\x64",
     0x00000395 => "\x65",
     0x00000396 => "\x7a",
     0x00000397 => "\x68",
     0x00000398 => "\x75",
     0x00000399 => "\x69",
     0x0000039a => "\x6b",
     0x0000039b => "\x6c",
     0x0000039c => "\x6d",
     0x0000039d => "\x6e",
     0x0000039e => "\x6a",
     0x0000039f => "\x6f",
     0x000003a0 => "\x70",
     0x000003a1 => "\x72",
     0x000003a3 => "\x73",
     0x000003a4 => "\x74",
     0x000003a5 => "\x79",
     0x000003a6 => "\x66",
     0x000003a7 => "\x78",
     0x000003a8 => "\x63",
     0x000003a9 => "\x76",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/LATIN_GREEK_1.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::LATIN_GREEK_1;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x039e,
     0x0022,
     0x0393,
     0x00a4,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x03a8,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x03a0,
     0x0394,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x03a9,
     0x0398,
     0x03a6,
     0x039b,
     0x03a3,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x203e,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\xce\x9e",
     "\x22",
     "\xce\x93",
     "\xc2\xa4",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\xce\xa8",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\xce\xa0",
     "\xce\x94",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xce\xa9",
     "\xce\x98",
     "\xce\xa6",
     "\xce\x9b",
     "\xce\xa3",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\xe2\x80\xbe",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000022 => "\x22",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007f => "\x7f",
     0x000000a4 => "\x24",
     0x00000393 => "\x23",
     0x00000394 => "\x40",
     0x00000398 => "\x5c",
     0x0000039b => "\x5e",
     0x0000039e => "\x21",
     0x000003a0 => "\x3f",
     0x000003a3 => "\x5f",
     0x000003a6 => "\x5d",
     0x000003a8 => "\x3a",
     0x000003a9 => "\x5b",
     0x0000203e => "\x7e",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MACARABIC.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MACARABIC;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c4,
     0x00a0,
     0x00c7,
     0x00c9,
     0x00d1,
     0x00d6,
     0x00dc,
     0x00e1,
     0x00e0,
     0x00e2,
     0x00e4,
     0x06ba,
     0x00ab,
     0x00e7,
     0x00e9,
     0x00e8,
     0x00ea,
     0x00eb,
     0x00ed,
     0x2026,
     0x00ee,
     0x00ef,
     0x00f1,
     0x00f3,
     0x00bb,
     0x00f4,
     0x00f6,
     0x00f7,
     0x00fa,
     0x00f9,
     0x00fb,
     0x00fc,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x066a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x060c,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0660,
     0x0661,
     0x0662,
     0x0663,
     0x0664,
     0x0665,
     0x0666,
     0x0667,
     0x0668,
     0x0669,
     0xfffd,
     0x061b,
     0xfffd,
     0xfffd,
     0xfffd,
     0x061f,
     0x066d,
     0x0621,
     0x0622,
     0x0623,
     0x0624,
     0x0625,
     0x0626,
     0x0627,
     0x0628,
     0x0629,
     0x062a,
     0x062b,
     0x062c,
     0x062d,
     0x062e,
     0x062f,
     0x0630,
     0x0631,
     0x0632,
     0x0633,
     0x0634,
     0x0635,
     0x0636,
     0x0637,
     0x0638,
     0x0639,
     0x063a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0640,
     0x0641,
     0x0642,
     0x0643,
     0x0644,
     0x0645,
     0x0646,
     0x0647,
     0x0648,
     0x0649,
     0x064a,
     0x064b,
     0x064c,
     0x064d,
     0x064e,
     0x064f,
     0x0650,
     0x0651,
     0x0652,
     0x067e,
     0x0679,
     0x0686,
     0x06d5,
     0x06a4,
     0x06af,
     0x0688,
     0x0691,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0698,
     0x06d2,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x84",
     "\xc2\xa0",
     "\xc3\x87",
     "\xc3\x89",
     "\xc3\x91",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xa1",
     "\xc3\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xda\xba",
     "\xc2\xab",
     "\xc3\xa7",
     "\xc3\xa9",
     "\xc3\xa8",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xad",
     "\xe2\x80\xa6",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb1",
     "\xc3\xb3",
     "\xc2\xbb",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc3\xba",
     "\xc3\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd9\xaa",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd8\x8c",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd9\xa0",
     "\xd9\xa1",
     "\xd9\xa2",
     "\xd9\xa3",
     "\xd9\xa4",
     "\xd9\xa5",
     "\xd9\xa6",
     "\xd9\xa7",
     "\xd9\xa8",
     "\xd9\xa9",
     "\xef\xbf\xbd",
     "\xd8\x9b",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd8\x9f",
     "\xd9\xad",
     "\xd8\xa1",
     "\xd8\xa2",
     "\xd8\xa3",
     "\xd8\xa4",
     "\xd8\xa5",
     "\xd8\xa6",
     "\xd8\xa7",
     "\xd8\xa8",
     "\xd8\xa9",
     "\xd8\xaa",
     "\xd8\xab",
     "\xd8\xac",
     "\xd8\xad",
     "\xd8\xae",
     "\xd8\xaf",
     "\xd8\xb0",
     "\xd8\xb1",
     "\xd8\xb2",
     "\xd8\xb3",
     "\xd8\xb4",
     "\xd8\xb5",
     "\xd8\xb6",
     "\xd8\xb7",
     "\xd8\xb8",
     "\xd8\xb9",
     "\xd8\xba",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd9\x80",
     "\xd9\x81",
     "\xd9\x82",
     "\xd9\x83",
     "\xd9\x84",
     "\xd9\x85",
     "\xd9\x86",
     "\xd9\x87",
     "\xd9\x88",
     "\xd9\x89",
     "\xd9\x8a",
     "\xd9\x8b",
     "\xd9\x8c",
     "\xd9\x8d",
     "\xd9\x8e",
     "\xd9\x8f",
     "\xd9\x90",
     "\xd9\x91",
     "\xd9\x92",
     "\xd9\xbe",
     "\xd9\xb9",
     "\xda\x86",
     "\xdb\x95",
     "\xda\xa4",
     "\xda\xaf",
     "\xda\x88",
     "\xda\x91",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xda\x98",
     "\xdb\x92",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\x81",
     0x000000ab => "\x8c",
     0x000000bb => "\x98",
     0x000000c4 => "\x80",
     0x000000c7 => "\x82",
     0x000000c9 => "\x83",
     0x000000d1 => "\x84",
     0x000000d6 => "\x85",
     0x000000dc => "\x86",
     0x000000e0 => "\x88",
     0x000000e1 => "\x87",
     0x000000e2 => "\x89",
     0x000000e4 => "\x8a",
     0x000000e7 => "\x8d",
     0x000000e8 => "\x8f",
     0x000000e9 => "\x8e",
     0x000000ea => "\x90",
     0x000000eb => "\x91",
     0x000000ed => "\x92",
     0x000000ee => "\x94",
     0x000000ef => "\x95",
     0x000000f1 => "\x96",
     0x000000f3 => "\x97",
     0x000000f4 => "\x99",
     0x000000f6 => "\x9a",
     0x000000f7 => "\x9b",
     0x000000f9 => "\x9d",
     0x000000fa => "\x9c",
     0x000000fb => "\x9e",
     0x000000fc => "\x9f",
     0x0000060c => "\xac",
     0x0000061b => "\xbb",
     0x0000061f => "\xbf",
     0x00000621 => "\xc1",
     0x00000622 => "\xc2",
     0x00000623 => "\xc3",
     0x00000624 => "\xc4",
     0x00000625 => "\xc5",
     0x00000626 => "\xc6",
     0x00000627 => "\xc7",
     0x00000628 => "\xc8",
     0x00000629 => "\xc9",
     0x0000062a => "\xca",
     0x0000062b => "\xcb",
     0x0000062c => "\xcc",
     0x0000062d => "\xcd",
     0x0000062e => "\xce",
     0x0000062f => "\xcf",
     0x00000630 => "\xd0",
     0x00000631 => "\xd1",
     0x00000632 => "\xd2",
     0x00000633 => "\xd3",
     0x00000634 => "\xd4",
     0x00000635 => "\xd5",
     0x00000636 => "\xd6",
     0x00000637 => "\xd7",
     0x00000638 => "\xd8",
     0x00000639 => "\xd9",
     0x0000063a => "\xda",
     0x00000640 => "\xe0",
     0x00000641 => "\xe1",
     0x00000642 => "\xe2",
     0x00000643 => "\xe3",
     0x00000644 => "\xe4",
     0x00000645 => "\xe5",
     0x00000646 => "\xe6",
     0x00000647 => "\xe7",
     0x00000648 => "\xe8",
     0x00000649 => "\xe9",
     0x0000064a => "\xea",
     0x0000064b => "\xeb",
     0x0000064c => "\xec",
     0x0000064d => "\xed",
     0x0000064e => "\xee",
     0x0000064f => "\xef",
     0x00000650 => "\xf0",
     0x00000651 => "\xf1",
     0x00000652 => "\xf2",
     0x00000660 => "\xb0",
     0x00000661 => "\xb1",
     0x00000662 => "\xb2",
     0x00000663 => "\xb3",
     0x00000664 => "\xb4",
     0x00000665 => "\xb5",
     0x00000666 => "\xb6",
     0x00000667 => "\xb7",
     0x00000668 => "\xb8",
     0x00000669 => "\xb9",
     0x0000066a => "\xa5",
     0x0000066d => "\xc0",
     0x00000679 => "\xf4",
     0x0000067e => "\xf3",
     0x00000686 => "\xf5",
     0x00000688 => "\xf9",
     0x00000691 => "\xfa",
     0x00000698 => "\xfe",
     0x000006a4 => "\xf7",
     0x000006af => "\xf8",
     0x000006ba => "\x8b",
     0x000006d2 => "\xff",
     0x000006d5 => "\xf6",
     0x00002026 => "\x93",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MACCROATIAN.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MACCROATIAN;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c4,
     0x00c5,
     0x00c7,
     0x00c9,
     0x00d1,
     0x00d6,
     0x00dc,
     0x00e1,
     0x00e0,
     0x00e2,
     0x00e4,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00e9,
     0x00e8,
     0x00ea,
     0x00eb,
     0x00ed,
     0x00ec,
     0x00ee,
     0x00ef,
     0x00f1,
     0x00f3,
     0x00f2,
     0x00f4,
     0x00f6,
     0x00f5,
     0x00fa,
     0x00f9,
     0x00fb,
     0x00fc,
     0x2020,
     0x00b0,
     0x00a2,
     0x00a3,
     0x00a7,
     0x2022,
     0x00b6,
     0x00df,
     0x00ae,
     0x0160,
     0x2122,
     0x00b4,
     0x00a8,
     0x2260,
     0x017d,
     0x00d8,
     0x221e,
     0x00b1,
     0x2264,
     0x2265,
     0x2206,
     0x00b5,
     0x2202,
     0x2211,
     0x220f,
     0x0161,
     0x222b,
     0x00aa,
     0x00ba,
     0x2126,
     0x017e,
     0x00f8,
     0x00bf,
     0x00a1,
     0x00ac,
     0x221a,
     0x0192,
     0x2248,
     0x0106,
     0x00ab,
     0x010c,
     0x2026,
     0x00a0,
     0x00c0,
     0x00c3,
     0x00d5,
     0x0152,
     0x0153,
     0x0110,
     0x2014,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x25ca,
     0xfffd,
     0x00a9,
     0x2044,
     0x00a4,
     0x2039,
     0x203a,
     0x00c6,
     0x00bb,
     0x2013,
     0x00b7,
     0x201a,
     0x201e,
     0x2030,
     0x00c2,
     0x0107,
     0x00c1,
     0x010d,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x00d3,
     0x00d4,
     0x0111,
     0x00d2,
     0x00da,
     0x00db,
     0x00d9,
     0x0131,
     0x02c6,
     0x02dc,
     0x00af,
     0x03c0,
     0x00cb,
     0x02da,
     0x00b8,
     0x00ca,
     0x00e6,
     0x02c7,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x89",
     "\xc3\x91",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xa1",
     "\xc3\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xa9",
     "\xc3\xa8",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xad",
     "\xc3\xac",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb1",
     "\xc3\xb3",
     "\xc3\xb2",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb5",
     "\xc3\xba",
     "\xc3\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xe2\x80\xa0",
     "\xc2\xb0",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa7",
     "\xe2\x80\xa2",
     "\xc2\xb6",
     "\xc3\x9f",
     "\xc2\xae",
     "\xc5\xa0",
     "\xe2\x84\xa2",
     "\xc2\xb4",
     "\xc2\xa8",
     "\xe2\x89\xa0",
     "\xc5\xbd",
     "\xc3\x98",
     "\xe2\x88\x9e",
     "\xc2\xb1",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xe2\x88\x86",
     "\xc2\xb5",
     "\xe2\x88\x82",
     "\xe2\x88\x91",
     "\xe2\x88\x8f",
     "\xc5\xa1",
     "\xe2\x88\xab",
     "\xc2\xaa",
     "\xc2\xba",
     "\xe2\x84\xa6",
     "\xc5\xbe",
     "\xc3\xb8",
     "\xc2\xbf",
     "\xc2\xa1",
     "\xc2\xac",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x89\x88",
     "\xc4\x86",
     "\xc2\xab",
     "\xc4\x8c",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xc3\x80",
     "\xc3\x83",
     "\xc3\x95",
     "\xc5\x92",
     "\xc5\x93",
     "\xc4\x90",
     "\xe2\x80\x94",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xe2\x97\x8a",
     "\xef\xbf\xbd",
     "\xc2\xa9",
     "\xe2\x81\x84",
     "\xc2\xa4",
     "\xe2\x80\xb9",
     "\xe2\x80\xba",
     "\xc3\x86",
     "\xc2\xbb",
     "\xe2\x80\x93",
     "\xc2\xb7",
     "\xe2\x80\x9a",
     "\xe2\x80\x9e",
     "\xe2\x80\xb0",
     "\xc3\x82",
     "\xc4\x87",
     "\xc3\x81",
     "\xc4\x8d",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc3\x93",
     "\xc3\x94",
     "\xc4\x91",
     "\xc3\x92",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x99",
     "\xc4\xb1",
     "\xcb\x86",
     "\xcb\x9c",
     "\xc2\xaf",
     "\xcf\x80",
     "\xc3\x8b",
     "\xcb\x9a",
     "\xc2\xb8",
     "\xc3\x8a",
     "\xc3\xa6",
     "\xcb\x87",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a1 => "\xc1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xdb",
     0x000000a7 => "\xa4",
     0x000000a8 => "\xac",
     0x000000a9 => "\xd9",
     0x000000aa => "\xbb",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ae => "\xa8",
     0x000000af => "\xf8",
     0x000000b0 => "\xa1",
     0x000000b1 => "\xb1",
     0x000000b4 => "\xab",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xa6",
     0x000000b7 => "\xe1",
     0x000000b8 => "\xfc",
     0x000000ba => "\xbc",
     0x000000bb => "\xdf",
     0x000000bf => "\xc0",
     0x000000c0 => "\xcb",
     0x000000c1 => "\xe7",
     0x000000c2 => "\xe5",
     0x000000c3 => "\xcc",
     0x000000c4 => "\x80",
     0x000000c5 => "\x81",
     0x000000c6 => "\xde",
     0x000000c7 => "\x82",
     0x000000c8 => "\xe9",
     0x000000c9 => "\x83",
     0x000000ca => "\xfd",
     0x000000cb => "\xfa",
     0x000000cc => "\xed",
     0x000000cd => "\xea",
     0x000000ce => "\xeb",
     0x000000cf => "\xec",
     0x000000d1 => "\x84",
     0x000000d2 => "\xf1",
     0x000000d3 => "\xee",
     0x000000d4 => "\xef",
     0x000000d5 => "\xcd",
     0x000000d6 => "\x85",
     0x000000d8 => "\xaf",
     0x000000d9 => "\xf4",
     0x000000da => "\xf2",
     0x000000db => "\xf3",
     0x000000dc => "\x86",
     0x000000df => "\xa7",
     0x000000e0 => "\x88",
     0x000000e1 => "\x87",
     0x000000e2 => "\x89",
     0x000000e3 => "\x8b",
     0x000000e4 => "\x8a",
     0x000000e5 => "\x8c",
     0x000000e6 => "\xfe",
     0x000000e7 => "\x8d",
     0x000000e8 => "\x8f",
     0x000000e9 => "\x8e",
     0x000000ea => "\x90",
     0x000000eb => "\x91",
     0x000000ec => "\x93",
     0x000000ed => "\x92",
     0x000000ee => "\x94",
     0x000000ef => "\x95",
     0x000000f1 => "\x96",
     0x000000f2 => "\x98",
     0x000000f3 => "\x97",
     0x000000f4 => "\x99",
     0x000000f5 => "\x9b",
     0x000000f6 => "\x9a",
     0x000000f7 => "\xd6",
     0x000000f8 => "\xbf",
     0x000000f9 => "\x9d",
     0x000000fa => "\x9c",
     0x000000fb => "\x9e",
     0x000000fc => "\x9f",
     0x00000106 => "\xc6",
     0x00000107 => "\xe6",
     0x0000010c => "\xc8",
     0x0000010d => "\xe8",
     0x00000110 => "\xd0",
     0x00000111 => "\xf0",
     0x00000131 => "\xf5",
     0x00000152 => "\xce",
     0x00000153 => "\xcf",
     0x00000160 => "\xa9",
     0x00000161 => "\xb9",
     0x0000017d => "\xae",
     0x0000017e => "\xbe",
     0x00000192 => "\xc4",
     0x000002c6 => "\xf6",
     0x000002c7 => "\xff",
     0x000002da => "\xfb",
     0x000002dc => "\xf7",
     0x000003c0 => "\xf9",
     0x00002013 => "\xe0",
     0x00002014 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201a => "\xe2",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xe3",
     0x00002020 => "\xa0",
     0x00002022 => "\xa5",
     0x00002026 => "\xc9",
     0x00002030 => "\xe4",
     0x00002039 => "\xdc",
     0x0000203a => "\xdd",
     0x00002044 => "\xda",
     0x00002122 => "\xaa",
     0x00002126 => "\xbd",
     0x00002202 => "\xb6",
     0x00002206 => "\xb4",
     0x0000220f => "\xb8",
     0x00002211 => "\xb7",
     0x0000221a => "\xc3",
     0x0000221e => "\xb0",
     0x0000222b => "\xba",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x00002264 => "\xb2",
     0x00002265 => "\xb3",
     0x000025ca => "\xd7",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MACCYRILLIC.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MACCYRILLIC;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0410,
     0x0411,
     0x0412,
     0x0413,
     0x0414,
     0x0415,
     0x0416,
     0x0417,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0424,
     0x0425,
     0x0426,
     0x0427,
     0x0428,
     0x0429,
     0x042a,
     0x042b,
     0x042c,
     0x042d,
     0x042e,
     0x042f,
     0x2020,
     0x00b0,
     0x00a2,
     0x00a3,
     0x00a7,
     0x2022,
     0x00b6,
     0x0406,
     0x00ae,
     0x00a9,
     0x2122,
     0x0402,
     0x0452,
     0x2260,
     0x0403,
     0x0453,
     0x221e,
     0x00b1,
     0x2264,
     0x2265,
     0x0456,
     0x00b5,
     0x2202,
     0x0408,
     0x0404,
     0x0454,
     0x0407,
     0x0457,
     0x0409,
     0x0459,
     0x040a,
     0x045a,
     0x0458,
     0x0405,
     0x00ac,
     0x221a,
     0x0192,
     0x2248,
     0x2206,
     0x00ab,
     0x00bb,
     0x2026,
     0x00a0,
     0x040b,
     0x045b,
     0x040c,
     0x045c,
     0x0455,
     0x2013,
     0x2014,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x201e,
     0x040e,
     0x045e,
     0x040f,
     0x045f,
     0x2116,
     0x0401,
     0x0451,
     0x044f,
     0x0430,
     0x0431,
     0x0432,
     0x0433,
     0x0434,
     0x0435,
     0x0436,
     0x0437,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0444,
     0x0445,
     0x0446,
     0x0447,
     0x0448,
     0x0449,
     0x044a,
     0x044b,
     0x044c,
     0x044d,
     0x044e,
     0x00a4,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\x92",
     "\xd0\x93",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\x96",
     "\xd0\x97",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\xa4",
     "\xd0\xa5",
     "\xd0\xa6",
     "\xd0\xa7",
     "\xd0\xa8",
     "\xd0\xa9",
     "\xd0\xaa",
     "\xd0\xab",
     "\xd0\xac",
     "\xd0\xad",
     "\xd0\xae",
     "\xd0\xaf",
     "\xe2\x80\xa0",
     "\xc2\xb0",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa7",
     "\xe2\x80\xa2",
     "\xc2\xb6",
     "\xd0\x86",
     "\xc2\xae",
     "\xc2\xa9",
     "\xe2\x84\xa2",
     "\xd0\x82",
     "\xd1\x92",
     "\xe2\x89\xa0",
     "\xd0\x83",
     "\xd1\x93",
     "\xe2\x88\x9e",
     "\xc2\xb1",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xd1\x96",
     "\xc2\xb5",
     "\xe2\x88\x82",
     "\xd0\x88",
     "\xd0\x84",
     "\xd1\x94",
     "\xd0\x87",
     "\xd1\x97",
     "\xd0\x89",
     "\xd1\x99",
     "\xd0\x8a",
     "\xd1\x9a",
     "\xd1\x98",
     "\xd0\x85",
     "\xc2\xac",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x89\x88",
     "\xe2\x88\x86",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xd0\x8b",
     "\xd1\x9b",
     "\xd0\x8c",
     "\xd1\x9c",
     "\xd1\x95",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xe2\x80\x9e",
     "\xd0\x8e",
     "\xd1\x9e",
     "\xd0\x8f",
     "\xd1\x9f",
     "\xe2\x84\x96",
     "\xd0\x81",
     "\xd1\x91",
     "\xd1\x8f",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd0\xb2",
     "\xd0\xb3",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd0\xb6",
     "\xd0\xb7",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd1\x84",
     "\xd1\x85",
     "\xd1\x86",
     "\xd1\x87",
     "\xd1\x88",
     "\xd1\x89",
     "\xd1\x8a",
     "\xd1\x8b",
     "\xd1\x8c",
     "\xd1\x8d",
     "\xd1\x8e",
     "\xc2\xa4",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xff",
     0x000000a7 => "\xa4",
     0x000000a9 => "\xa9",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ae => "\xa8",
     0x000000b0 => "\xa1",
     0x000000b1 => "\xb1",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xa6",
     0x000000bb => "\xc8",
     0x000000f7 => "\xd6",
     0x00000192 => "\xc4",
     0x00000401 => "\xdd",
     0x00000402 => "\xab",
     0x00000403 => "\xae",
     0x00000404 => "\xb8",
     0x00000405 => "\xc1",
     0x00000406 => "\xa7",
     0x00000407 => "\xba",
     0x00000408 => "\xb7",
     0x00000409 => "\xbc",
     0x0000040a => "\xbe",
     0x0000040b => "\xcb",
     0x0000040c => "\xcd",
     0x0000040e => "\xd8",
     0x0000040f => "\xda",
     0x00000410 => "\x80",
     0x00000411 => "\x81",
     0x00000412 => "\x82",
     0x00000413 => "\x83",
     0x00000414 => "\x84",
     0x00000415 => "\x85",
     0x00000416 => "\x86",
     0x00000417 => "\x87",
     0x00000418 => "\x88",
     0x00000419 => "\x89",
     0x0000041a => "\x8a",
     0x0000041b => "\x8b",
     0x0000041c => "\x8c",
     0x0000041d => "\x8d",
     0x0000041e => "\x8e",
     0x0000041f => "\x8f",
     0x00000420 => "\x90",
     0x00000421 => "\x91",
     0x00000422 => "\x92",
     0x00000423 => "\x93",
     0x00000424 => "\x94",
     0x00000425 => "\x95",
     0x00000426 => "\x96",
     0x00000427 => "\x97",
     0x00000428 => "\x98",
     0x00000429 => "\x99",
     0x0000042a => "\x9a",
     0x0000042b => "\x9b",
     0x0000042c => "\x9c",
     0x0000042d => "\x9d",
     0x0000042e => "\x9e",
     0x0000042f => "\x9f",
     0x00000430 => "\xe0",
     0x00000431 => "\xe1",
     0x00000432 => "\xe2",
     0x00000433 => "\xe3",
     0x00000434 => "\xe4",
     0x00000435 => "\xe5",
     0x00000436 => "\xe6",
     0x00000437 => "\xe7",
     0x00000438 => "\xe8",
     0x00000439 => "\xe9",
     0x0000043a => "\xea",
     0x0000043b => "\xeb",
     0x0000043c => "\xec",
     0x0000043d => "\xed",
     0x0000043e => "\xee",
     0x0000043f => "\xef",
     0x00000440 => "\xf0",
     0x00000441 => "\xf1",
     0x00000442 => "\xf2",
     0x00000443 => "\xf3",
     0x00000444 => "\xf4",
     0x00000445 => "\xf5",
     0x00000446 => "\xf6",
     0x00000447 => "\xf7",
     0x00000448 => "\xf8",
     0x00000449 => "\xf9",
     0x0000044a => "\xfa",
     0x0000044b => "\xfb",
     0x0000044c => "\xfc",
     0x0000044d => "\xfd",
     0x0000044e => "\xfe",
     0x0000044f => "\xdf",
     0x00000451 => "\xde",
     0x00000452 => "\xac",
     0x00000453 => "\xaf",
     0x00000454 => "\xb9",
     0x00000455 => "\xcf",
     0x00000456 => "\xb4",
     0x00000457 => "\xbb",
     0x00000458 => "\xc0",
     0x00000459 => "\xbd",
     0x0000045a => "\xbf",
     0x0000045b => "\xcc",
     0x0000045c => "\xce",
     0x0000045e => "\xd9",
     0x0000045f => "\xdb",
     0x00002013 => "\xd0",
     0x00002014 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xd7",
     0x00002020 => "\xa0",
     0x00002022 => "\xa5",
     0x00002026 => "\xc9",
     0x00002116 => "\xdc",
     0x00002122 => "\xaa",
     0x00002202 => "\xb6",
     0x00002206 => "\xc6",
     0x0000221a => "\xc3",
     0x0000221e => "\xb0",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x00002264 => "\xb2",
     0x00002265 => "\xb3",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MACGREEK.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MACGREEK;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c4,
     0x00b9,
     0x00b2,
     0x00c9,
     0x00b3,
     0x00d6,
     0x00dc,
     0x0385,
     0x00e0,
     0x00e2,
     0x00e4,
     0x0384,
     0x00a8,
     0x00e7,
     0x00e9,
     0x00e8,
     0x00ea,
     0x00eb,
     0x00a3,
     0x2122,
     0x00ee,
     0x00ef,
     0x2022,
     0x00bd,
     0x2030,
     0x00f4,
     0x00f6,
     0x00a6,
     0x00ad,
     0x00f9,
     0x00fb,
     0x00fc,
     0x2020,
     0x0393,
     0x0394,
     0x0398,
     0x039b,
     0x039e,
     0x03a0,
     0x00df,
     0x00ae,
     0x00a9,
     0x03a3,
     0x03aa,
     0x00a7,
     0x2260,
     0x00b0,
     0x0387,
     0x0391,
     0x00b1,
     0x2264,
     0x2265,
     0x00a5,
     0x0392,
     0x0395,
     0x0396,
     0x0397,
     0x0399,
     0x039a,
     0x039c,
     0x03a6,
     0x03ab,
     0x03a8,
     0x03a9,
     0x03ac,
     0x039d,
     0x00ac,
     0x039f,
     0x03a1,
     0x2248,
     0x03a4,
     0x00ab,
     0x00bb,
     0x2026,
     0x00a0,
     0x03a5,
     0x03a7,
     0x0386,
     0x0388,
     0x0153,
     0x2013,
     0x2015,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x0389,
     0x038a,
     0x038c,
     0x038e,
     0x03ad,
     0x03ae,
     0x03af,
     0x03cc,
     0x038f,
     0x03cd,
     0x03b1,
     0x03b2,
     0x03c8,
     0x03b4,
     0x03b5,
     0x03c6,
     0x03b3,
     0x03b7,
     0x03b9,
     0x03be,
     0x03ba,
     0x03bb,
     0x03bc,
     0x03bd,
     0x03bf,
     0x03c0,
     0x03ce,
     0x03c1,
     0x03c3,
     0x03c4,
     0x03b8,
     0x03c9,
     0x03c2,
     0x03c7,
     0x03c5,
     0x03b6,
     0x03ca,
     0x03cb,
     0x0390,
     0x03b0,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x84",
     "\xc2\xb9",
     "\xc2\xb2",
     "\xc3\x89",
     "\xc2\xb3",
     "\xc3\x96",
     "\xc3\x9c",
     "\xce\x85",
     "\xc3\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xce\x84",
     "\xc2\xa8",
     "\xc3\xa7",
     "\xc3\xa9",
     "\xc3\xa8",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc2\xa3",
     "\xe2\x84\xa2",
     "\xc3\xae",
     "\xc3\xaf",
     "\xe2\x80\xa2",
     "\xc2\xbd",
     "\xe2\x80\xb0",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc2\xa6",
     "\xc2\xad",
     "\xc3\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xe2\x80\xa0",
     "\xce\x93",
     "\xce\x94",
     "\xce\x98",
     "\xce\x9b",
     "\xce\x9e",
     "\xce\xa0",
     "\xc3\x9f",
     "\xc2\xae",
     "\xc2\xa9",
     "\xce\xa3",
     "\xce\xaa",
     "\xc2\xa7",
     "\xe2\x89\xa0",
     "\xc2\xb0",
     "\xce\x87",
     "\xce\x91",
     "\xc2\xb1",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xc2\xa5",
     "\xce\x92",
     "\xce\x95",
     "\xce\x96",
     "\xce\x97",
     "\xce\x99",
     "\xce\x9a",
     "\xce\x9c",
     "\xce\xa6",
     "\xce\xab",
     "\xce\xa8",
     "\xce\xa9",
     "\xce\xac",
     "\xce\x9d",
     "\xc2\xac",
     "\xce\x9f",
     "\xce\xa1",
     "\xe2\x89\x88",
     "\xce\xa4",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xce\xa5",
     "\xce\xa7",
     "\xce\x86",
     "\xce\x88",
     "\xc5\x93",
     "\xe2\x80\x93",
     "\xe2\x80\x95",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xce\x89",
     "\xce\x8a",
     "\xce\x8c",
     "\xce\x8e",
     "\xce\xad",
     "\xce\xae",
     "\xce\xaf",
     "\xcf\x8c",
     "\xce\x8f",
     "\xcf\x8d",
     "\xce\xb1",
     "\xce\xb2",
     "\xcf\x88",
     "\xce\xb4",
     "\xce\xb5",
     "\xcf\x86",
     "\xce\xb3",
     "\xce\xb7",
     "\xce\xb9",
     "\xce\xbe",
     "\xce\xba",
     "\xce\xbb",
     "\xce\xbc",
     "\xce\xbd",
     "\xce\xbf",
     "\xcf\x80",
     "\xcf\x8e",
     "\xcf\x81",
     "\xcf\x83",
     "\xcf\x84",
     "\xce\xb8",
     "\xcf\x89",
     "\xcf\x82",
     "\xcf\x87",
     "\xcf\x85",
     "\xce\xb6",
     "\xcf\x8a",
     "\xcf\x8b",
     "\xce\x90",
     "\xce\xb0",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a3 => "\x92",
     0x000000a5 => "\xb4",
     0x000000a6 => "\x9b",
     0x000000a7 => "\xac",
     0x000000a8 => "\x8c",
     0x000000a9 => "\xa9",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ad => "\x9c",
     0x000000ae => "\xa8",
     0x000000b0 => "\xae",
     0x000000b1 => "\xb1",
     0x000000b2 => "\x82",
     0x000000b3 => "\x84",
     0x000000b9 => "\x81",
     0x000000bb => "\xc8",
     0x000000bd => "\x97",
     0x000000c4 => "\x80",
     0x000000c9 => "\x83",
     0x000000d6 => "\x85",
     0x000000dc => "\x86",
     0x000000df => "\xa7",
     0x000000e0 => "\x88",
     0x000000e2 => "\x89",
     0x000000e4 => "\x8a",
     0x000000e7 => "\x8d",
     0x000000e8 => "\x8f",
     0x000000e9 => "\x8e",
     0x000000ea => "\x90",
     0x000000eb => "\x91",
     0x000000ee => "\x94",
     0x000000ef => "\x95",
     0x000000f4 => "\x99",
     0x000000f6 => "\x9a",
     0x000000f7 => "\xd6",
     0x000000f9 => "\x9d",
     0x000000fb => "\x9e",
     0x000000fc => "\x9f",
     0x00000153 => "\xcf",
     0x00000384 => "\x8b",
     0x00000385 => "\x87",
     0x00000386 => "\xcd",
     0x00000387 => "\xaf",
     0x00000388 => "\xce",
     0x00000389 => "\xd7",
     0x0000038a => "\xd8",
     0x0000038c => "\xd9",
     0x0000038e => "\xda",
     0x0000038f => "\xdf",
     0x00000390 => "\xfd",
     0x00000391 => "\xb0",
     0x00000392 => "\xb5",
     0x00000393 => "\xa1",
     0x00000394 => "\xa2",
     0x00000395 => "\xb6",
     0x00000396 => "\xb7",
     0x00000397 => "\xb8",
     0x00000398 => "\xa3",
     0x00000399 => "\xb9",
     0x0000039a => "\xba",
     0x0000039b => "\xa4",
     0x0000039c => "\xbb",
     0x0000039d => "\xc1",
     0x0000039e => "\xa5",
     0x0000039f => "\xc3",
     0x000003a0 => "\xa6",
     0x000003a1 => "\xc4",
     0x000003a3 => "\xaa",
     0x000003a4 => "\xc6",
     0x000003a5 => "\xcb",
     0x000003a6 => "\xbc",
     0x000003a7 => "\xcc",
     0x000003a8 => "\xbe",
     0x000003a9 => "\xbf",
     0x000003aa => "\xab",
     0x000003ab => "\xbd",
     0x000003ac => "\xc0",
     0x000003ad => "\xdb",
     0x000003ae => "\xdc",
     0x000003af => "\xdd",
     0x000003b0 => "\xfe",
     0x000003b1 => "\xe1",
     0x000003b2 => "\xe2",
     0x000003b3 => "\xe7",
     0x000003b4 => "\xe4",
     0x000003b5 => "\xe5",
     0x000003b6 => "\xfa",
     0x000003b7 => "\xe8",
     0x000003b8 => "\xf5",
     0x000003b9 => "\xe9",
     0x000003ba => "\xeb",
     0x000003bb => "\xec",
     0x000003bc => "\xed",
     0x000003bd => "\xee",
     0x000003be => "\xea",
     0x000003bf => "\xef",
     0x000003c0 => "\xf0",
     0x000003c1 => "\xf2",
     0x000003c2 => "\xf7",
     0x000003c3 => "\xf3",
     0x000003c4 => "\xf4",
     0x000003c5 => "\xf9",
     0x000003c6 => "\xe6",
     0x000003c7 => "\xf8",
     0x000003c8 => "\xe3",
     0x000003c9 => "\xf6",
     0x000003ca => "\xfb",
     0x000003cb => "\xfc",
     0x000003cc => "\xde",
     0x000003cd => "\xe0",
     0x000003ce => "\xf1",
     0x00002013 => "\xd0",
     0x00002015 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x00002020 => "\xa0",
     0x00002022 => "\x96",
     0x00002026 => "\xc9",
     0x00002030 => "\x98",
     0x00002122 => "\x93",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x00002264 => "\xb2",
     0x00002265 => "\xb3",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MACHEBREW.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MACHEBREW;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c4,
     0xfb1f,
     0x00c7,
     0x00c9,
     0x00d1,
     0x00d6,
     0x00dc,
     0x00e1,
     0x00e0,
     0x00e2,
     0x00e4,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00e9,
     0x00e8,
     0x00ea,
     0x00eb,
     0x00ed,
     0x00ec,
     0x00ee,
     0x00ef,
     0x00f1,
     0x00f3,
     0x00f2,
     0x00f4,
     0x00f6,
     0x00f5,
     0x00fa,
     0x00f9,
     0x00fb,
     0x00fc,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x20aa,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x201e,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x05bc,
     0xfb4b,
     0xfb35,
     0x2026,
     0x00a0,
     0x05b8,
     0x05b7,
     0x05b5,
     0x05b6,
     0x05b4,
     0x2013,
     0x2014,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0xfb2a,
     0xfb2b,
     0x05bf,
     0x05b0,
     0x05b2,
     0x05b1,
     0x05bb,
     0x05b9,
     0xfffd,
     0x05b3,
     0x05d0,
     0x05d1,
     0x05d2,
     0x05d3,
     0x05d4,
     0x05d5,
     0x05d6,
     0x05d7,
     0x05d8,
     0x05d9,
     0x05da,
     0x05db,
     0x05dc,
     0x05dd,
     0x05de,
     0x05df,
     0x05e0,
     0x05e1,
     0x05e2,
     0x05e3,
     0x05e4,
     0x05e5,
     0x05e6,
     0x05e7,
     0x05e8,
     0x05e9,
     0x05ea,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x84",
     "\xef\xac\x9f",
     "\xc3\x87",
     "\xc3\x89",
     "\xc3\x91",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xa1",
     "\xc3\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xa9",
     "\xc3\xa8",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xad",
     "\xc3\xac",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb1",
     "\xc3\xb3",
     "\xc3\xb2",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb5",
     "\xc3\xba",
     "\xc3\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x82\xaa",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\x9e",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xd6\xbc",
     "\xef\xad\x8b",
     "\xef\xac\xb5",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xd6\xb8",
     "\xd6\xb7",
     "\xd6\xb5",
     "\xd6\xb6",
     "\xd6\xb4",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xef\xac\xaa",
     "\xef\xac\xab",
     "\xd6\xbf",
     "\xd6\xb0",
     "\xd6\xb2",
     "\xd6\xb1",
     "\xd6\xbb",
     "\xd6\xb9",
     "\xef\xbf\xbd",
     "\xd6\xb3",
     "\xd7\x90",
     "\xd7\x91",
     "\xd7\x92",
     "\xd7\x93",
     "\xd7\x94",
     "\xd7\x95",
     "\xd7\x96",
     "\xd7\x97",
     "\xd7\x98",
     "\xd7\x99",
     "\xd7\x9a",
     "\xd7\x9b",
     "\xd7\x9c",
     "\xd7\x9d",
     "\xd7\x9e",
     "\xd7\x9f",
     "\xd7\xa0",
     "\xd7\xa1",
     "\xd7\xa2",
     "\xd7\xa3",
     "\xd7\xa4",
     "\xd7\xa5",
     "\xd7\xa6",
     "\xd7\xa7",
     "\xd7\xa8",
     "\xd7\xa9",
     "\xd7\xaa",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000c4 => "\x80",
     0x000000c7 => "\x82",
     0x000000c9 => "\x83",
     0x000000d1 => "\x84",
     0x000000d6 => "\x85",
     0x000000dc => "\x86",
     0x000000e0 => "\x88",
     0x000000e1 => "\x87",
     0x000000e2 => "\x89",
     0x000000e3 => "\x8b",
     0x000000e4 => "\x8a",
     0x000000e5 => "\x8c",
     0x000000e7 => "\x8d",
     0x000000e8 => "\x8f",
     0x000000e9 => "\x8e",
     0x000000ea => "\x90",
     0x000000eb => "\x91",
     0x000000ec => "\x93",
     0x000000ed => "\x92",
     0x000000ee => "\x94",
     0x000000ef => "\x95",
     0x000000f1 => "\x96",
     0x000000f2 => "\x98",
     0x000000f3 => "\x97",
     0x000000f4 => "\x99",
     0x000000f5 => "\x9b",
     0x000000f6 => "\x9a",
     0x000000f9 => "\x9d",
     0x000000fa => "\x9c",
     0x000000fb => "\x9e",
     0x000000fc => "\x9f",
     0x000005b0 => "\xd9",
     0x000005b1 => "\xdb",
     0x000005b2 => "\xda",
     0x000005b3 => "\xdf",
     0x000005b4 => "\xcf",
     0x000005b5 => "\xcd",
     0x000005b6 => "\xce",
     0x000005b7 => "\xcc",
     0x000005b8 => "\xcb",
     0x000005b9 => "\xdd",
     0x000005bb => "\xdc",
     0x000005bc => "\xc6",
     0x000005bf => "\xd8",
     0x000005d0 => "\xe0",
     0x000005d1 => "\xe1",
     0x000005d2 => "\xe2",
     0x000005d3 => "\xe3",
     0x000005d4 => "\xe4",
     0x000005d5 => "\xe5",
     0x000005d6 => "\xe6",
     0x000005d7 => "\xe7",
     0x000005d8 => "\xe8",
     0x000005d9 => "\xe9",
     0x000005da => "\xea",
     0x000005db => "\xeb",
     0x000005dc => "\xec",
     0x000005dd => "\xed",
     0x000005de => "\xee",
     0x000005df => "\xef",
     0x000005e0 => "\xf0",
     0x000005e1 => "\xf1",
     0x000005e2 => "\xf2",
     0x000005e3 => "\xf3",
     0x000005e4 => "\xf4",
     0x000005e5 => "\xf5",
     0x000005e6 => "\xf6",
     0x000005e7 => "\xf7",
     0x000005e8 => "\xf8",
     0x000005e9 => "\xf9",
     0x000005ea => "\xfa",
     0x00002013 => "\xd0",
     0x00002014 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xc1",
     0x00002026 => "\xc9",
     0x000020aa => "\xa6",
     0x0000fb1f => "\x81",
     0x0000fb2a => "\xd6",
     0x0000fb2b => "\xd7",
     0x0000fb35 => "\xc8",
     0x0000fb4b => "\xc7",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MACICELAND.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MACICELAND;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c4,
     0x00c5,
     0x00c7,
     0x00c9,
     0x00d1,
     0x00d6,
     0x00dc,
     0x00e1,
     0x00e0,
     0x00e2,
     0x00e4,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00e9,
     0x00e8,
     0x00ea,
     0x00eb,
     0x00ed,
     0x00ec,
     0x00ee,
     0x00ef,
     0x00f1,
     0x00f3,
     0x00f2,
     0x00f4,
     0x00f6,
     0x00f5,
     0x00fa,
     0x00f9,
     0x00fb,
     0x00fc,
     0x00dd,
     0x00b0,
     0x00a2,
     0x00a3,
     0x00a7,
     0x2022,
     0x00b6,
     0x00df,
     0x00ae,
     0x00a9,
     0x2122,
     0x00b4,
     0x00a8,
     0x2260,
     0x00c6,
     0x00d8,
     0x221e,
     0x00b1,
     0x2264,
     0x2265,
     0x00a5,
     0x00b5,
     0x2202,
     0x2211,
     0x220f,
     0x03c0,
     0x222b,
     0x00aa,
     0x00ba,
     0x2126,
     0x00e6,
     0x00f8,
     0x00bf,
     0x00a1,
     0x00ac,
     0x221a,
     0x0192,
     0x2248,
     0x2206,
     0x00ab,
     0x00bb,
     0x2026,
     0x00a0,
     0x00c0,
     0x00c3,
     0x00d5,
     0x0152,
     0x0153,
     0x2013,
     0x2014,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x25ca,
     0x00ff,
     0x0178,
     0x2044,
     0x00a4,
     0x00d0,
     0x00f0,
     0x00de,
     0x00fe,
     0x00fd,
     0x00b7,
     0x201a,
     0x201e,
     0x2030,
     0x00c2,
     0x00ca,
     0x00c1,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x00d3,
     0x00d4,
     0xfffd,
     0x00d2,
     0x00da,
     0x00db,
     0x00d9,
     0x0131,
     0x02c6,
     0x02dc,
     0x00af,
     0x02d8,
     0x02d9,
     0x02da,
     0x00b8,
     0x02dd,
     0x02db,
     0x02c7,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x89",
     "\xc3\x91",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xa1",
     "\xc3\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xa9",
     "\xc3\xa8",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xad",
     "\xc3\xac",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb1",
     "\xc3\xb3",
     "\xc3\xb2",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb5",
     "\xc3\xba",
     "\xc3\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\x9d",
     "\xc2\xb0",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa7",
     "\xe2\x80\xa2",
     "\xc2\xb6",
     "\xc3\x9f",
     "\xc2\xae",
     "\xc2\xa9",
     "\xe2\x84\xa2",
     "\xc2\xb4",
     "\xc2\xa8",
     "\xe2\x89\xa0",
     "\xc3\x86",
     "\xc3\x98",
     "\xe2\x88\x9e",
     "\xc2\xb1",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xc2\xa5",
     "\xc2\xb5",
     "\xe2\x88\x82",
     "\xe2\x88\x91",
     "\xe2\x88\x8f",
     "\xcf\x80",
     "\xe2\x88\xab",
     "\xc2\xaa",
     "\xc2\xba",
     "\xe2\x84\xa6",
     "\xc3\xa6",
     "\xc3\xb8",
     "\xc2\xbf",
     "\xc2\xa1",
     "\xc2\xac",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x89\x88",
     "\xe2\x88\x86",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xc3\x80",
     "\xc3\x83",
     "\xc3\x95",
     "\xc5\x92",
     "\xc5\x93",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xe2\x97\x8a",
     "\xc3\xbf",
     "\xc5\xb8",
     "\xe2\x81\x84",
     "\xc2\xa4",
     "\xc3\x90",
     "\xc3\xb0",
     "\xc3\x9e",
     "\xc3\xbe",
     "\xc3\xbd",
     "\xc2\xb7",
     "\xe2\x80\x9a",
     "\xe2\x80\x9e",
     "\xe2\x80\xb0",
     "\xc3\x82",
     "\xc3\x8a",
     "\xc3\x81",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc3\x93",
     "\xc3\x94",
     "\xef\xbf\xbd",
     "\xc3\x92",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x99",
     "\xc4\xb1",
     "\xcb\x86",
     "\xcb\x9c",
     "\xc2\xaf",
     "\xcb\x98",
     "\xcb\x99",
     "\xcb\x9a",
     "\xc2\xb8",
     "\xcb\x9d",
     "\xcb\x9b",
     "\xcb\x87",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a1 => "\xc1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xdb",
     0x000000a5 => "\xb4",
     0x000000a7 => "\xa4",
     0x000000a8 => "\xac",
     0x000000a9 => "\xa9",
     0x000000aa => "\xbb",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ae => "\xa8",
     0x000000af => "\xf8",
     0x000000b0 => "\xa1",
     0x000000b1 => "\xb1",
     0x000000b4 => "\xab",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xa6",
     0x000000b7 => "\xe1",
     0x000000b8 => "\xfc",
     0x000000ba => "\xbc",
     0x000000bb => "\xc8",
     0x000000bf => "\xc0",
     0x000000c0 => "\xcb",
     0x000000c1 => "\xe7",
     0x000000c2 => "\xe5",
     0x000000c3 => "\xcc",
     0x000000c4 => "\x80",
     0x000000c5 => "\x81",
     0x000000c6 => "\xae",
     0x000000c7 => "\x82",
     0x000000c8 => "\xe9",
     0x000000c9 => "\x83",
     0x000000ca => "\xe6",
     0x000000cb => "\xe8",
     0x000000cc => "\xed",
     0x000000cd => "\xea",
     0x000000ce => "\xeb",
     0x000000cf => "\xec",
     0x000000d0 => "\xdc",
     0x000000d1 => "\x84",
     0x000000d2 => "\xf1",
     0x000000d3 => "\xee",
     0x000000d4 => "\xef",
     0x000000d5 => "\xcd",
     0x000000d6 => "\x85",
     0x000000d8 => "\xaf",
     0x000000d9 => "\xf4",
     0x000000da => "\xf2",
     0x000000db => "\xf3",
     0x000000dc => "\x86",
     0x000000dd => "\xa0",
     0x000000de => "\xde",
     0x000000df => "\xa7",
     0x000000e0 => "\x88",
     0x000000e1 => "\x87",
     0x000000e2 => "\x89",
     0x000000e3 => "\x8b",
     0x000000e4 => "\x8a",
     0x000000e5 => "\x8c",
     0x000000e6 => "\xbe",
     0x000000e7 => "\x8d",
     0x000000e8 => "\x8f",
     0x000000e9 => "\x8e",
     0x000000ea => "\x90",
     0x000000eb => "\x91",
     0x000000ec => "\x93",
     0x000000ed => "\x92",
     0x000000ee => "\x94",
     0x000000ef => "\x95",
     0x000000f0 => "\xdd",
     0x000000f1 => "\x96",
     0x000000f2 => "\x98",
     0x000000f3 => "\x97",
     0x000000f4 => "\x99",
     0x000000f5 => "\x9b",
     0x000000f6 => "\x9a",
     0x000000f7 => "\xd6",
     0x000000f8 => "\xbf",
     0x000000f9 => "\x9d",
     0x000000fa => "\x9c",
     0x000000fb => "\x9e",
     0x000000fc => "\x9f",
     0x000000fd => "\xe0",
     0x000000fe => "\xdf",
     0x000000ff => "\xd8",
     0x00000131 => "\xf5",
     0x00000152 => "\xce",
     0x00000153 => "\xcf",
     0x00000178 => "\xd9",
     0x00000192 => "\xc4",
     0x000002c6 => "\xf6",
     0x000002c7 => "\xff",
     0x000002d8 => "\xf9",
     0x000002d9 => "\xfa",
     0x000002da => "\xfb",
     0x000002db => "\xfe",
     0x000002dc => "\xf7",
     0x000002dd => "\xfd",
     0x000003c0 => "\xb9",
     0x00002013 => "\xd0",
     0x00002014 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201a => "\xe2",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xe3",
     0x00002022 => "\xa5",
     0x00002026 => "\xc9",
     0x00002030 => "\xe4",
     0x00002044 => "\xda",
     0x00002122 => "\xaa",
     0x00002126 => "\xbd",
     0x00002202 => "\xb6",
     0x00002206 => "\xc6",
     0x0000220f => "\xb8",
     0x00002211 => "\xb7",
     0x0000221a => "\xc3",
     0x0000221e => "\xb0",
     0x0000222b => "\xba",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x00002264 => "\xb2",
     0x00002265 => "\xb3",
     0x000025ca => "\xd7",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MACINTOSH.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MACINTOSH;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c4,
     0x00c5,
     0x00c7,
     0x00c9,
     0x00d1,
     0x00d6,
     0x00dc,
     0x00e1,
     0x00e0,
     0x00e2,
     0x00e4,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00e9,
     0x00e8,
     0x00ea,
     0x00eb,
     0x00ed,
     0x00ec,
     0x00ee,
     0x00ef,
     0x00f1,
     0x00f3,
     0x00f2,
     0x00f4,
     0x00f6,
     0x00f5,
     0x00fa,
     0x00f9,
     0x00fb,
     0x00fc,
     0x2020,
     0x00b0,
     0x00a2,
     0x00a3,
     0x00a7,
     0x2022,
     0x00b6,
     0x00df,
     0x00ae,
     0x00a9,
     0x2122,
     0x00b4,
     0x00a8,
     0x2260,
     0x00c6,
     0x00d8,
     0x221e,
     0x00b1,
     0x2264,
     0x2265,
     0x00a5,
     0x00b5,
     0x2202,
     0x2211,
     0x220f,
     0x03c0,
     0x222b,
     0x00aa,
     0x00ba,
     0x03a9,
     0x00e6,
     0x00f8,
     0x00bf,
     0x00a1,
     0x00ac,
     0x221a,
     0x0192,
     0x2248,
     0x0394,
     0x00ab,
     0x00bb,
     0x2026,
     0x00a0,
     0x00c0,
     0x00c3,
     0x00d5,
     0x0152,
     0x0153,
     0x2013,
     0x2014,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x25ca,
     0x00ff,
     0x0178,
     0x2044,
     0x20ac,
     0x2039,
     0x203a,
     0xfb01,
     0xfb02,
     0x2021,
     0x00b7,
     0x201a,
     0x201e,
     0x2030,
     0x00c2,
     0x00ca,
     0x00c1,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x00d3,
     0x00d4,
     0xe01e,
     0x00d2,
     0x00da,
     0x00db,
     0x00d9,
     0x0131,
     0x02c6,
     0x02dc,
     0x00af,
     0x02d8,
     0x02d9,
     0x02da,
     0x00b8,
     0x02dd,
     0x02db,
     0x02c7,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x89",
     "\xc3\x91",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xa1",
     "\xc3\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xa9",
     "\xc3\xa8",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xad",
     "\xc3\xac",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb1",
     "\xc3\xb3",
     "\xc3\xb2",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb5",
     "\xc3\xba",
     "\xc3\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xe2\x80\xa0",
     "\xc2\xb0",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa7",
     "\xe2\x80\xa2",
     "\xc2\xb6",
     "\xc3\x9f",
     "\xc2\xae",
     "\xc2\xa9",
     "\xe2\x84\xa2",
     "\xc2\xb4",
     "\xc2\xa8",
     "\xe2\x89\xa0",
     "\xc3\x86",
     "\xc3\x98",
     "\xe2\x88\x9e",
     "\xc2\xb1",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xc2\xa5",
     "\xc2\xb5",
     "\xe2\x88\x82",
     "\xe2\x88\x91",
     "\xe2\x88\x8f",
     "\xcf\x80",
     "\xe2\x88\xab",
     "\xc2\xaa",
     "\xc2\xba",
     "\xce\xa9",
     "\xc3\xa6",
     "\xc3\xb8",
     "\xc2\xbf",
     "\xc2\xa1",
     "\xc2\xac",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x89\x88",
     "\xce\x94",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xc3\x80",
     "\xc3\x83",
     "\xc3\x95",
     "\xc5\x92",
     "\xc5\x93",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xe2\x97\x8a",
     "\xc3\xbf",
     "\xc5\xb8",
     "\xe2\x81\x84",
     "\xe2\x82\xac",
     "\xe2\x80\xb9",
     "\xe2\x80\xba",
     "\xef\xac\x81",
     "\xef\xac\x82",
     "\xe2\x80\xa1",
     "\xc2\xb7",
     "\xe2\x80\x9a",
     "\xe2\x80\x9e",
     "\xe2\x80\xb0",
     "\xc3\x82",
     "\xc3\x8a",
     "\xc3\x81",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc3\x93",
     "\xc3\x94",
     "\xee\x80\x9e",
     "\xc3\x92",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x99",
     "\xc4\xb1",
     "\xcb\x86",
     "\xcb\x9c",
     "\xc2\xaf",
     "\xcb\x98",
     "\xcb\x99",
     "\xcb\x9a",
     "\xc2\xb8",
     "\xcb\x9d",
     "\xcb\x9b",
     "\xcb\x87",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a1 => "\xc1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a5 => "\xb4",
     0x000000a7 => "\xa4",
     0x000000a8 => "\xac",
     0x000000a9 => "\xa9",
     0x000000aa => "\xbb",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ae => "\xa8",
     0x000000af => "\xf8",
     0x000000b0 => "\xa1",
     0x000000b1 => "\xb1",
     0x000000b4 => "\xab",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xa6",
     0x000000b7 => "\xe1",
     0x000000b8 => "\xfc",
     0x000000ba => "\xbc",
     0x000000bb => "\xc8",
     0x000000bf => "\xc0",
     0x000000c0 => "\xcb",
     0x000000c1 => "\xe7",
     0x000000c2 => "\xe5",
     0x000000c3 => "\xcc",
     0x000000c4 => "\x80",
     0x000000c5 => "\x81",
     0x000000c6 => "\xae",
     0x000000c7 => "\x82",
     0x000000c8 => "\xe9",
     0x000000c9 => "\x83",
     0x000000ca => "\xe6",
     0x000000cb => "\xe8",
     0x000000cc => "\xed",
     0x000000cd => "\xea",
     0x000000ce => "\xeb",
     0x000000cf => "\xec",
     0x000000d1 => "\x84",
     0x000000d2 => "\xf1",
     0x000000d3 => "\xee",
     0x000000d4 => "\xef",
     0x000000d5 => "\xcd",
     0x000000d6 => "\x85",
     0x000000d8 => "\xaf",
     0x000000d9 => "\xf4",
     0x000000da => "\xf2",
     0x000000db => "\xf3",
     0x000000dc => "\x86",
     0x000000df => "\xa7",
     0x000000e0 => "\x88",
     0x000000e1 => "\x87",
     0x000000e2 => "\x89",
     0x000000e3 => "\x8b",
     0x000000e4 => "\x8a",
     0x000000e5 => "\x8c",
     0x000000e6 => "\xbe",
     0x000000e7 => "\x8d",
     0x000000e8 => "\x8f",
     0x000000e9 => "\x8e",
     0x000000ea => "\x90",
     0x000000eb => "\x91",
     0x000000ec => "\x93",
     0x000000ed => "\x92",
     0x000000ee => "\x94",
     0x000000ef => "\x95",
     0x000000f1 => "\x96",
     0x000000f2 => "\x98",
     0x000000f3 => "\x97",
     0x000000f4 => "\x99",
     0x000000f5 => "\x9b",
     0x000000f6 => "\x9a",
     0x000000f7 => "\xd6",
     0x000000f8 => "\xbf",
     0x000000f9 => "\x9d",
     0x000000fa => "\x9c",
     0x000000fb => "\x9e",
     0x000000fc => "\x9f",
     0x000000ff => "\xd8",
     0x00000131 => "\xf5",
     0x00000152 => "\xce",
     0x00000153 => "\xcf",
     0x00000178 => "\xd9",
     0x00000192 => "\xc4",
     0x000002c6 => "\xf6",
     0x000002c7 => "\xff",
     0x000002d8 => "\xf9",
     0x000002d9 => "\xfa",
     0x000002da => "\xfb",
     0x000002db => "\xfe",
     0x000002dc => "\xf7",
     0x000002dd => "\xfd",
     0x00000394 => "\xc6",
     0x000003a9 => "\xbd",
     0x000003c0 => "\xb9",
     0x00002013 => "\xd0",
     0x00002014 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201a => "\xe2",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xe3",
     0x00002020 => "\xa0",
     0x00002021 => "\xe0",
     0x00002022 => "\xa5",
     0x00002026 => "\xc9",
     0x00002030 => "\xe4",
     0x00002039 => "\xdc",
     0x0000203a => "\xdd",
     0x00002044 => "\xda",
     0x000020ac => "\xdb",
     0x00002122 => "\xaa",
     0x00002202 => "\xb6",
     0x0000220f => "\xb8",
     0x00002211 => "\xb7",
     0x0000221a => "\xc3",
     0x0000221e => "\xb0",
     0x0000222b => "\xba",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x00002264 => "\xb2",
     0x00002265 => "\xb3",
     0x000025ca => "\xd7",
     0x0000e01e => "\xf0",
     0x0000fb01 => "\xde",
     0x0000fb02 => "\xdf",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MACROMANIA.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MACROMANIA;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c4,
     0x00c5,
     0x00c7,
     0x00c9,
     0x00d1,
     0x00d6,
     0x00dc,
     0x00e1,
     0x00e0,
     0x00e2,
     0x00e4,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00e9,
     0x00e8,
     0x00ea,
     0x00eb,
     0x00ed,
     0x00ec,
     0x00ee,
     0x00ef,
     0x00f1,
     0x00f3,
     0x00f2,
     0x00f4,
     0x00f6,
     0x00f5,
     0x00fa,
     0x00f9,
     0x00fb,
     0x00fc,
     0x2020,
     0x00b0,
     0x00a2,
     0x00a3,
     0x00a7,
     0x2022,
     0x00b6,
     0x00df,
     0x00ae,
     0x00a9,
     0x2122,
     0x00b4,
     0x00a8,
     0x2260,
     0x0102,
     0x015e,
     0x221e,
     0x00b1,
     0x2264,
     0x2265,
     0x00a5,
     0x00b5,
     0x2202,
     0x2211,
     0x220f,
     0x03c0,
     0x222b,
     0x00aa,
     0x00ba,
     0x2126,
     0x0103,
     0x015f,
     0x00bf,
     0x00a1,
     0x00ac,
     0x221a,
     0x0192,
     0x2248,
     0x2206,
     0x00ab,
     0x00bb,
     0x2026,
     0x00a0,
     0x00c0,
     0x00c3,
     0x00d5,
     0x0152,
     0x0153,
     0x2013,
     0x2014,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x25ca,
     0x00ff,
     0x0178,
     0x2044,
     0x00a4,
     0x2039,
     0x203a,
     0x0162,
     0x0163,
     0x2021,
     0x00b7,
     0x201a,
     0x201e,
     0x2030,
     0x00c2,
     0x00ca,
     0x00c1,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x00d3,
     0x00d4,
     0xfffd,
     0x00d2,
     0x00da,
     0x00db,
     0x00d9,
     0x0131,
     0x02c6,
     0x02dc,
     0x00af,
     0x02d8,
     0x02d9,
     0x02da,
     0x00b8,
     0x02dd,
     0x02db,
     0x02c7,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x89",
     "\xc3\x91",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xa1",
     "\xc3\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xa9",
     "\xc3\xa8",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xad",
     "\xc3\xac",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb1",
     "\xc3\xb3",
     "\xc3\xb2",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb5",
     "\xc3\xba",
     "\xc3\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xe2\x80\xa0",
     "\xc2\xb0",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa7",
     "\xe2\x80\xa2",
     "\xc2\xb6",
     "\xc3\x9f",
     "\xc2\xae",
     "\xc2\xa9",
     "\xe2\x84\xa2",
     "\xc2\xb4",
     "\xc2\xa8",
     "\xe2\x89\xa0",
     "\xc4\x82",
     "\xc5\x9e",
     "\xe2\x88\x9e",
     "\xc2\xb1",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xc2\xa5",
     "\xc2\xb5",
     "\xe2\x88\x82",
     "\xe2\x88\x91",
     "\xe2\x88\x8f",
     "\xcf\x80",
     "\xe2\x88\xab",
     "\xc2\xaa",
     "\xc2\xba",
     "\xe2\x84\xa6",
     "\xc4\x83",
     "\xc5\x9f",
     "\xc2\xbf",
     "\xc2\xa1",
     "\xc2\xac",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x89\x88",
     "\xe2\x88\x86",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xc3\x80",
     "\xc3\x83",
     "\xc3\x95",
     "\xc5\x92",
     "\xc5\x93",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xe2\x97\x8a",
     "\xc3\xbf",
     "\xc5\xb8",
     "\xe2\x81\x84",
     "\xc2\xa4",
     "\xe2\x80\xb9",
     "\xe2\x80\xba",
     "\xc5\xa2",
     "\xc5\xa3",
     "\xe2\x80\xa1",
     "\xc2\xb7",
     "\xe2\x80\x9a",
     "\xe2\x80\x9e",
     "\xe2\x80\xb0",
     "\xc3\x82",
     "\xc3\x8a",
     "\xc3\x81",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc3\x93",
     "\xc3\x94",
     "\xef\xbf\xbd",
     "\xc3\x92",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x99",
     "\xc4\xb1",
     "\xcb\x86",
     "\xcb\x9c",
     "\xc2\xaf",
     "\xcb\x98",
     "\xcb\x99",
     "\xcb\x9a",
     "\xc2\xb8",
     "\xcb\x9d",
     "\xcb\x9b",
     "\xcb\x87",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a1 => "\xc1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xdb",
     0x000000a5 => "\xb4",
     0x000000a7 => "\xa4",
     0x000000a8 => "\xac",
     0x000000a9 => "\xa9",
     0x000000aa => "\xbb",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ae => "\xa8",
     0x000000af => "\xf8",
     0x000000b0 => "\xa1",
     0x000000b1 => "\xb1",
     0x000000b4 => "\xab",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xa6",
     0x000000b7 => "\xe1",
     0x000000b8 => "\xfc",
     0x000000ba => "\xbc",
     0x000000bb => "\xc8",
     0x000000bf => "\xc0",
     0x000000c0 => "\xcb",
     0x000000c1 => "\xe7",
     0x000000c2 => "\xe5",
     0x000000c3 => "\xcc",
     0x000000c4 => "\x80",
     0x000000c5 => "\x81",
     0x000000c7 => "\x82",
     0x000000c8 => "\xe9",
     0x000000c9 => "\x83",
     0x000000ca => "\xe6",
     0x000000cb => "\xe8",
     0x000000cc => "\xed",
     0x000000cd => "\xea",
     0x000000ce => "\xeb",
     0x000000cf => "\xec",
     0x000000d1 => "\x84",
     0x000000d2 => "\xf1",
     0x000000d3 => "\xee",
     0x000000d4 => "\xef",
     0x000000d5 => "\xcd",
     0x000000d6 => "\x85",
     0x000000d9 => "\xf4",
     0x000000da => "\xf2",
     0x000000db => "\xf3",
     0x000000dc => "\x86",
     0x000000df => "\xa7",
     0x000000e0 => "\x88",
     0x000000e1 => "\x87",
     0x000000e2 => "\x89",
     0x000000e3 => "\x8b",
     0x000000e4 => "\x8a",
     0x000000e5 => "\x8c",
     0x000000e7 => "\x8d",
     0x000000e8 => "\x8f",
     0x000000e9 => "\x8e",
     0x000000ea => "\x90",
     0x000000eb => "\x91",
     0x000000ec => "\x93",
     0x000000ed => "\x92",
     0x000000ee => "\x94",
     0x000000ef => "\x95",
     0x000000f1 => "\x96",
     0x000000f2 => "\x98",
     0x000000f3 => "\x97",
     0x000000f4 => "\x99",
     0x000000f5 => "\x9b",
     0x000000f6 => "\x9a",
     0x000000f7 => "\xd6",
     0x000000f9 => "\x9d",
     0x000000fa => "\x9c",
     0x000000fb => "\x9e",
     0x000000fc => "\x9f",
     0x000000ff => "\xd8",
     0x00000102 => "\xae",
     0x00000103 => "\xbe",
     0x00000131 => "\xf5",
     0x00000152 => "\xce",
     0x00000153 => "\xcf",
     0x0000015e => "\xaf",
     0x0000015f => "\xbf",
     0x00000162 => "\xde",
     0x00000163 => "\xdf",
     0x00000178 => "\xd9",
     0x00000192 => "\xc4",
     0x000002c6 => "\xf6",
     0x000002c7 => "\xff",
     0x000002d8 => "\xf9",
     0x000002d9 => "\xfa",
     0x000002da => "\xfb",
     0x000002db => "\xfe",
     0x000002dc => "\xf7",
     0x000002dd => "\xfd",
     0x000003c0 => "\xb9",
     0x00002013 => "\xd0",
     0x00002014 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201a => "\xe2",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xe3",
     0x00002020 => "\xa0",
     0x00002021 => "\xe0",
     0x00002022 => "\xa5",
     0x00002026 => "\xc9",
     0x00002030 => "\xe4",
     0x00002039 => "\xdc",
     0x0000203a => "\xdd",
     0x00002044 => "\xda",
     0x00002122 => "\xaa",
     0x00002126 => "\xbd",
     0x00002202 => "\xb6",
     0x00002206 => "\xc6",
     0x0000220f => "\xb8",
     0x00002211 => "\xb7",
     0x0000221a => "\xc3",
     0x0000221e => "\xb0",
     0x0000222b => "\xba",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x00002264 => "\xb2",
     0x00002265 => "\xb3",
     0x000025ca => "\xd7",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MACTHAI.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MACTHAI;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00ab,
     0x00bb,
     0x2026,
     0xf88c,
     0xf88f,
     0xf892,
     0xf895,
     0xf898,
     0xf88b,
     0xf88e,
     0xf891,
     0xf894,
     0xf897,
     0x201c,
     0x201d,
     0xf899,
     0xfffd,
     0x2022,
     0xf884,
     0xf889,
     0xf885,
     0xf886,
     0xf887,
     0xf888,
     0xf88a,
     0xf88d,
     0xf890,
     0xf893,
     0xf896,
     0x2018,
     0x2019,
     0xfffd,
     0x00a0,
     0x0e01,
     0x0e02,
     0x0e03,
     0x0e04,
     0x0e05,
     0x0e06,
     0x0e07,
     0x0e08,
     0x0e09,
     0x0e0a,
     0x0e0b,
     0x0e0c,
     0x0e0d,
     0x0e0e,
     0x0e0f,
     0x0e10,
     0x0e11,
     0x0e12,
     0x0e13,
     0x0e14,
     0x0e15,
     0x0e16,
     0x0e17,
     0x0e18,
     0x0e19,
     0x0e1a,
     0x0e1b,
     0x0e1c,
     0x0e1d,
     0x0e1e,
     0x0e1f,
     0x0e20,
     0x0e21,
     0x0e22,
     0x0e23,
     0x0e24,
     0x0e25,
     0x0e26,
     0x0e27,
     0x0e28,
     0x0e29,
     0x0e2a,
     0x0e2b,
     0x0e2c,
     0x0e2d,
     0x0e2e,
     0x0e2f,
     0x0e30,
     0x0e31,
     0x0e32,
     0x0e33,
     0x0e34,
     0x0e35,
     0x0e36,
     0x0e37,
     0x0e38,
     0x0e39,
     0x0e3a,
     0xfeff,
     0x200b,
     0x2013,
     0x2014,
     0x0e3f,
     0x0e40,
     0x0e41,
     0x0e42,
     0x0e43,
     0x0e44,
     0x0e45,
     0x0e46,
     0x0e47,
     0x0e48,
     0x0e49,
     0x0e4a,
     0x0e4b,
     0x0e4c,
     0x0e4d,
     0x2122,
     0x0e4f,
     0x0e50,
     0x0e51,
     0x0e52,
     0x0e53,
     0x0e54,
     0x0e55,
     0x0e56,
     0x0e57,
     0x0e58,
     0x0e59,
     0x00ae,
     0x00a9,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xef\xa2\x8c",
     "\xef\xa2\x8f",
     "\xef\xa2\x92",
     "\xef\xa2\x95",
     "\xef\xa2\x98",
     "\xef\xa2\x8b",
     "\xef\xa2\x8e",
     "\xef\xa2\x91",
     "\xef\xa2\x94",
     "\xef\xa2\x97",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xef\xa2\x99",
     "\xef\xbf\xbd",
     "\xe2\x80\xa2",
     "\xef\xa2\x84",
     "\xef\xa2\x89",
     "\xef\xa2\x85",
     "\xef\xa2\x86",
     "\xef\xa2\x87",
     "\xef\xa2\x88",
     "\xef\xa2\x8a",
     "\xef\xa2\x8d",
     "\xef\xa2\x90",
     "\xef\xa2\x93",
     "\xef\xa2\x96",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xef\xbf\xbd",
     "\xc2\xa0",
     "\xe0\xb8\x81",
     "\xe0\xb8\x82",
     "\xe0\xb8\x83",
     "\xe0\xb8\x84",
     "\xe0\xb8\x85",
     "\xe0\xb8\x86",
     "\xe0\xb8\x87",
     "\xe0\xb8\x88",
     "\xe0\xb8\x89",
     "\xe0\xb8\x8a",
     "\xe0\xb8\x8b",
     "\xe0\xb8\x8c",
     "\xe0\xb8\x8d",
     "\xe0\xb8\x8e",
     "\xe0\xb8\x8f",
     "\xe0\xb8\x90",
     "\xe0\xb8\x91",
     "\xe0\xb8\x92",
     "\xe0\xb8\x93",
     "\xe0\xb8\x94",
     "\xe0\xb8\x95",
     "\xe0\xb8\x96",
     "\xe0\xb8\x97",
     "\xe0\xb8\x98",
     "\xe0\xb8\x99",
     "\xe0\xb8\x9a",
     "\xe0\xb8\x9b",
     "\xe0\xb8\x9c",
     "\xe0\xb8\x9d",
     "\xe0\xb8\x9e",
     "\xe0\xb8\x9f",
     "\xe0\xb8\xa0",
     "\xe0\xb8\xa1",
     "\xe0\xb8\xa2",
     "\xe0\xb8\xa3",
     "\xe0\xb8\xa4",
     "\xe0\xb8\xa5",
     "\xe0\xb8\xa6",
     "\xe0\xb8\xa7",
     "\xe0\xb8\xa8",
     "\xe0\xb8\xa9",
     "\xe0\xb8\xaa",
     "\xe0\xb8\xab",
     "\xe0\xb8\xac",
     "\xe0\xb8\xad",
     "\xe0\xb8\xae",
     "\xe0\xb8\xaf",
     "\xe0\xb8\xb0",
     "\xe0\xb8\xb1",
     "\xe0\xb8\xb2",
     "\xe0\xb8\xb3",
     "\xe0\xb8\xb4",
     "\xe0\xb8\xb5",
     "\xe0\xb8\xb6",
     "\xe0\xb8\xb7",
     "\xe0\xb8\xb8",
     "\xe0\xb8\xb9",
     "\xe0\xb8\xba",
     "\xef\xbb\xbf",
     "\xe2\x80\x8b",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xe0\xb8\xbf",
     "\xe0\xb9\x80",
     "\xe0\xb9\x81",
     "\xe0\xb9\x82",
     "\xe0\xb9\x83",
     "\xe0\xb9\x84",
     "\xe0\xb9\x85",
     "\xe0\xb9\x86",
     "\xe0\xb9\x87",
     "\xe0\xb9\x88",
     "\xe0\xb9\x89",
     "\xe0\xb9\x8a",
     "\xe0\xb9\x8b",
     "\xe0\xb9\x8c",
     "\xe0\xb9\x8d",
     "\xe2\x84\xa2",
     "\xe0\xb9\x8f",
     "\xe0\xb9\x90",
     "\xe0\xb9\x91",
     "\xe0\xb9\x92",
     "\xe0\xb9\x93",
     "\xe0\xb9\x94",
     "\xe0\xb9\x95",
     "\xe0\xb9\x96",
     "\xe0\xb9\x97",
     "\xe0\xb9\x98",
     "\xe0\xb9\x99",
     "\xc2\xae",
     "\xc2\xa9",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x000000a9 => "\xfb",
     0x000000ab => "\x80",
     0x000000ae => "\xfa",
     0x000000bb => "\x81",
     0x00000e01 => "\xa1",
     0x00000e02 => "\xa2",
     0x00000e03 => "\xa3",
     0x00000e04 => "\xa4",
     0x00000e05 => "\xa5",
     0x00000e06 => "\xa6",
     0x00000e07 => "\xa7",
     0x00000e08 => "\xa8",
     0x00000e09 => "\xa9",
     0x00000e0a => "\xaa",
     0x00000e0b => "\xab",
     0x00000e0c => "\xac",
     0x00000e0d => "\xad",
     0x00000e0e => "\xae",
     0x00000e0f => "\xaf",
     0x00000e10 => "\xb0",
     0x00000e11 => "\xb1",
     0x00000e12 => "\xb2",
     0x00000e13 => "\xb3",
     0x00000e14 => "\xb4",
     0x00000e15 => "\xb5",
     0x00000e16 => "\xb6",
     0x00000e17 => "\xb7",
     0x00000e18 => "\xb8",
     0x00000e19 => "\xb9",
     0x00000e1a => "\xba",
     0x00000e1b => "\xbb",
     0x00000e1c => "\xbc",
     0x00000e1d => "\xbd",
     0x00000e1e => "\xbe",
     0x00000e1f => "\xbf",
     0x00000e20 => "\xc0",
     0x00000e21 => "\xc1",
     0x00000e22 => "\xc2",
     0x00000e23 => "\xc3",
     0x00000e24 => "\xc4",
     0x00000e25 => "\xc5",
     0x00000e26 => "\xc6",
     0x00000e27 => "\xc7",
     0x00000e28 => "\xc8",
     0x00000e29 => "\xc9",
     0x00000e2a => "\xca",
     0x00000e2b => "\xcb",
     0x00000e2c => "\xcc",
     0x00000e2d => "\xcd",
     0x00000e2e => "\xce",
     0x00000e2f => "\xcf",
     0x00000e30 => "\xd0",
     0x00000e31 => "\xd1",
     0x00000e32 => "\xd2",
     0x00000e33 => "\xd3",
     0x00000e34 => "\xd4",
     0x00000e35 => "\xd5",
     0x00000e36 => "\xd6",
     0x00000e37 => "\xd7",
     0x00000e38 => "\xd8",
     0x00000e39 => "\xd9",
     0x00000e3a => "\xda",
     0x00000e3f => "\xdf",
     0x00000e40 => "\xe0",
     0x00000e41 => "\xe1",
     0x00000e42 => "\xe2",
     0x00000e43 => "\xe3",
     0x00000e44 => "\xe4",
     0x00000e45 => "\xe5",
     0x00000e46 => "\xe6",
     0x00000e47 => "\xe7",
     0x00000e48 => "\xe8",
     0x00000e49 => "\xe9",
     0x00000e4a => "\xea",
     0x00000e4b => "\xeb",
     0x00000e4c => "\xec",
     0x00000e4d => "\xed",
     0x00000e4f => "\xef",
     0x00000e50 => "\xf0",
     0x00000e51 => "\xf1",
     0x00000e52 => "\xf2",
     0x00000e53 => "\xf3",
     0x00000e54 => "\xf4",
     0x00000e55 => "\xf5",
     0x00000e56 => "\xf6",
     0x00000e57 => "\xf7",
     0x00000e58 => "\xf8",
     0x00000e59 => "\xf9",
     0x0000200b => "\xdc",
     0x00002013 => "\xdd",
     0x00002014 => "\xde",
     0x00002018 => "\x9d",
     0x00002019 => "\x9e",
     0x0000201c => "\x8d",
     0x0000201d => "\x8e",
     0x00002022 => "\x91",
     0x00002026 => "\x82",
     0x00002122 => "\xee",
     0x0000f884 => "\x92",
     0x0000f885 => "\x94",
     0x0000f886 => "\x95",
     0x0000f887 => "\x96",
     0x0000f888 => "\x97",
     0x0000f889 => "\x93",
     0x0000f88a => "\x98",
     0x0000f88b => "\x88",
     0x0000f88c => "\x83",
     0x0000f88d => "\x99",
     0x0000f88e => "\x89",
     0x0000f88f => "\x84",
     0x0000f890 => "\x9a",
     0x0000f891 => "\x8a",
     0x0000f892 => "\x85",
     0x0000f893 => "\x9b",
     0x0000f894 => "\x8b",
     0x0000f895 => "\x86",
     0x0000f896 => "\x9c",
     0x0000f897 => "\x8c",
     0x0000f898 => "\x87",
     0x0000f899 => "\x8f",
     0x0000feff => "\xdb",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MACTURKISH.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MACTURKISH;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c4,
     0x00c5,
     0x00c7,
     0x00c9,
     0x00d1,
     0x00d6,
     0x00dc,
     0x00e1,
     0x00e0,
     0x00e2,
     0x00e4,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00e9,
     0x00e8,
     0x00ea,
     0x00eb,
     0x00ed,
     0x00ec,
     0x00ee,
     0x00ef,
     0x00f1,
     0x00f3,
     0x00f2,
     0x00f4,
     0x00f6,
     0x00f5,
     0x00fa,
     0x00f9,
     0x00fb,
     0x00fc,
     0x2020,
     0x00b0,
     0x00a2,
     0x00a3,
     0x00a7,
     0x2022,
     0x00b6,
     0x00df,
     0x00ae,
     0x00a9,
     0x2122,
     0x00b4,
     0x00a8,
     0x2260,
     0x00c6,
     0x00d8,
     0x221e,
     0x00b1,
     0x2264,
     0x2265,
     0x00a5,
     0x00b5,
     0x2202,
     0x2211,
     0x220f,
     0x03c0,
     0x222b,
     0x00aa,
     0x00ba,
     0x2126,
     0x00e6,
     0x00f8,
     0x00bf,
     0x00a1,
     0x00ac,
     0x221a,
     0x0192,
     0x2248,
     0x2206,
     0x00ab,
     0x00bb,
     0x2026,
     0x00a0,
     0x00c0,
     0x00c3,
     0x00d5,
     0x0152,
     0x0153,
     0x2013,
     0x2014,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x25ca,
     0x00ff,
     0x0178,
     0x011e,
     0x011f,
     0x0130,
     0x0131,
     0x015e,
     0x015f,
     0x2021,
     0x00b7,
     0x201a,
     0x201e,
     0x2030,
     0x00c2,
     0x00ca,
     0x00c1,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x00d3,
     0x00d4,
     0xfffd,
     0x00d2,
     0x00da,
     0x00db,
     0x00d9,
     0xfffd,
     0x02c6,
     0x02dc,
     0x00af,
     0x02d8,
     0x02d9,
     0x02da,
     0x00b8,
     0x02dd,
     0x02db,
     0x02c7,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x89",
     "\xc3\x91",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xa1",
     "\xc3\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xa9",
     "\xc3\xa8",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xad",
     "\xc3\xac",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb1",
     "\xc3\xb3",
     "\xc3\xb2",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb5",
     "\xc3\xba",
     "\xc3\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xe2\x80\xa0",
     "\xc2\xb0",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa7",
     "\xe2\x80\xa2",
     "\xc2\xb6",
     "\xc3\x9f",
     "\xc2\xae",
     "\xc2\xa9",
     "\xe2\x84\xa2",
     "\xc2\xb4",
     "\xc2\xa8",
     "\xe2\x89\xa0",
     "\xc3\x86",
     "\xc3\x98",
     "\xe2\x88\x9e",
     "\xc2\xb1",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xc2\xa5",
     "\xc2\xb5",
     "\xe2\x88\x82",
     "\xe2\x88\x91",
     "\xe2\x88\x8f",
     "\xcf\x80",
     "\xe2\x88\xab",
     "\xc2\xaa",
     "\xc2\xba",
     "\xe2\x84\xa6",
     "\xc3\xa6",
     "\xc3\xb8",
     "\xc2\xbf",
     "\xc2\xa1",
     "\xc2\xac",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x89\x88",
     "\xe2\x88\x86",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xc3\x80",
     "\xc3\x83",
     "\xc3\x95",
     "\xc5\x92",
     "\xc5\x93",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xe2\x97\x8a",
     "\xc3\xbf",
     "\xc5\xb8",
     "\xc4\x9e",
     "\xc4\x9f",
     "\xc4\xb0",
     "\xc4\xb1",
     "\xc5\x9e",
     "\xc5\x9f",
     "\xe2\x80\xa1",
     "\xc2\xb7",
     "\xe2\x80\x9a",
     "\xe2\x80\x9e",
     "\xe2\x80\xb0",
     "\xc3\x82",
     "\xc3\x8a",
     "\xc3\x81",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc3\x93",
     "\xc3\x94",
     "\xef\xbf\xbd",
     "\xc3\x92",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x99",
     "\xef\xbf\xbd",
     "\xcb\x86",
     "\xcb\x9c",
     "\xc2\xaf",
     "\xcb\x98",
     "\xcb\x99",
     "\xcb\x9a",
     "\xc2\xb8",
     "\xcb\x9d",
     "\xcb\x9b",
     "\xcb\x87",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a1 => "\xc1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a5 => "\xb4",
     0x000000a7 => "\xa4",
     0x000000a8 => "\xac",
     0x000000a9 => "\xa9",
     0x000000aa => "\xbb",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ae => "\xa8",
     0x000000af => "\xf8",
     0x000000b0 => "\xa1",
     0x000000b1 => "\xb1",
     0x000000b4 => "\xab",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xa6",
     0x000000b7 => "\xe1",
     0x000000b8 => "\xfc",
     0x000000ba => "\xbc",
     0x000000bb => "\xc8",
     0x000000bf => "\xc0",
     0x000000c0 => "\xcb",
     0x000000c1 => "\xe7",
     0x000000c2 => "\xe5",
     0x000000c3 => "\xcc",
     0x000000c4 => "\x80",
     0x000000c5 => "\x81",
     0x000000c6 => "\xae",
     0x000000c7 => "\x82",
     0x000000c8 => "\xe9",
     0x000000c9 => "\x83",
     0x000000ca => "\xe6",
     0x000000cb => "\xe8",
     0x000000cc => "\xed",
     0x000000cd => "\xea",
     0x000000ce => "\xeb",
     0x000000cf => "\xec",
     0x000000d1 => "\x84",
     0x000000d2 => "\xf1",
     0x000000d3 => "\xee",
     0x000000d4 => "\xef",
     0x000000d5 => "\xcd",
     0x000000d6 => "\x85",
     0x000000d8 => "\xaf",
     0x000000d9 => "\xf4",
     0x000000da => "\xf2",
     0x000000db => "\xf3",
     0x000000dc => "\x86",
     0x000000df => "\xa7",
     0x000000e0 => "\x88",
     0x000000e1 => "\x87",
     0x000000e2 => "\x89",
     0x000000e3 => "\x8b",
     0x000000e4 => "\x8a",
     0x000000e5 => "\x8c",
     0x000000e6 => "\xbe",
     0x000000e7 => "\x8d",
     0x000000e8 => "\x8f",
     0x000000e9 => "\x8e",
     0x000000ea => "\x90",
     0x000000eb => "\x91",
     0x000000ec => "\x93",
     0x000000ed => "\x92",
     0x000000ee => "\x94",
     0x000000ef => "\x95",
     0x000000f1 => "\x96",
     0x000000f2 => "\x98",
     0x000000f3 => "\x97",
     0x000000f4 => "\x99",
     0x000000f5 => "\x9b",
     0x000000f6 => "\x9a",
     0x000000f7 => "\xd6",
     0x000000f8 => "\xbf",
     0x000000f9 => "\x9d",
     0x000000fa => "\x9c",
     0x000000fb => "\x9e",
     0x000000fc => "\x9f",
     0x000000ff => "\xd8",
     0x0000011e => "\xda",
     0x0000011f => "\xdb",
     0x00000130 => "\xdc",
     0x00000131 => "\xdd",
     0x00000152 => "\xce",
     0x00000153 => "\xcf",
     0x0000015e => "\xde",
     0x0000015f => "\xdf",
     0x00000178 => "\xd9",
     0x00000192 => "\xc4",
     0x000002c6 => "\xf6",
     0x000002c7 => "\xff",
     0x000002d8 => "\xf9",
     0x000002d9 => "\xfa",
     0x000002da => "\xfb",
     0x000002db => "\xfe",
     0x000002dc => "\xf7",
     0x000002dd => "\xfd",
     0x000003c0 => "\xb9",
     0x00002013 => "\xd0",
     0x00002014 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201a => "\xe2",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xe3",
     0x00002020 => "\xa0",
     0x00002021 => "\xe0",
     0x00002022 => "\xa5",
     0x00002026 => "\xc9",
     0x00002030 => "\xe4",
     0x00002122 => "\xaa",
     0x00002126 => "\xbd",
     0x00002202 => "\xb6",
     0x00002206 => "\xc6",
     0x0000220f => "\xb8",
     0x00002211 => "\xb7",
     0x0000221a => "\xc3",
     0x0000221e => "\xb0",
     0x0000222b => "\xba",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x00002264 => "\xb2",
     0x00002265 => "\xb3",
     0x000025ca => "\xd7",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MACUKRAINE.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MACUKRAINE;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0410,
     0x0411,
     0x0412,
     0x0413,
     0x0414,
     0x0415,
     0x0416,
     0x0417,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0424,
     0x0425,
     0x0426,
     0x0427,
     0x0428,
     0x0429,
     0x042a,
     0x042b,
     0x042c,
     0x042d,
     0x042e,
     0x042f,
     0x2020,
     0x00b0,
     0x0490,
     0x00a3,
     0x00a7,
     0x2022,
     0x00b6,
     0x0406,
     0x00ae,
     0x00a9,
     0x2122,
     0x0402,
     0x0452,
     0x2260,
     0x0403,
     0x0453,
     0x221e,
     0x00b1,
     0x2264,
     0x2265,
     0x0456,
     0x00b5,
     0x0491,
     0x0408,
     0x0404,
     0x0454,
     0x0407,
     0x0457,
     0x0409,
     0x0459,
     0x040a,
     0x045a,
     0x0458,
     0x0405,
     0x00ac,
     0x221a,
     0x0192,
     0x2248,
     0x2206,
     0x00ab,
     0x00bb,
     0x2026,
     0x00a0,
     0x040b,
     0x045b,
     0x040c,
     0x045c,
     0x0455,
     0x2013,
     0x2014,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x201e,
     0x040e,
     0x045e,
     0x040f,
     0x045f,
     0x2116,
     0x0401,
     0x0451,
     0x044f,
     0x0430,
     0x0431,
     0x0432,
     0x0433,
     0x0434,
     0x0435,
     0x0436,
     0x0437,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0444,
     0x0445,
     0x0446,
     0x0447,
     0x0448,
     0x0449,
     0x044a,
     0x044b,
     0x044c,
     0x044d,
     0x044e,
     0x00a4,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\x92",
     "\xd0\x93",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\x96",
     "\xd0\x97",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\xa4",
     "\xd0\xa5",
     "\xd0\xa6",
     "\xd0\xa7",
     "\xd0\xa8",
     "\xd0\xa9",
     "\xd0\xaa",
     "\xd0\xab",
     "\xd0\xac",
     "\xd0\xad",
     "\xd0\xae",
     "\xd0\xaf",
     "\xe2\x80\xa0",
     "\xc2\xb0",
     "\xd2\x90",
     "\xc2\xa3",
     "\xc2\xa7",
     "\xe2\x80\xa2",
     "\xc2\xb6",
     "\xd0\x86",
     "\xc2\xae",
     "\xc2\xa9",
     "\xe2\x84\xa2",
     "\xd0\x82",
     "\xd1\x92",
     "\xe2\x89\xa0",
     "\xd0\x83",
     "\xd1\x93",
     "\xe2\x88\x9e",
     "\xc2\xb1",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xd1\x96",
     "\xc2\xb5",
     "\xd2\x91",
     "\xd0\x88",
     "\xd0\x84",
     "\xd1\x94",
     "\xd0\x87",
     "\xd1\x97",
     "\xd0\x89",
     "\xd1\x99",
     "\xd0\x8a",
     "\xd1\x9a",
     "\xd1\x98",
     "\xd0\x85",
     "\xc2\xac",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x89\x88",
     "\xe2\x88\x86",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xd0\x8b",
     "\xd1\x9b",
     "\xd0\x8c",
     "\xd1\x9c",
     "\xd1\x95",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xe2\x80\x9e",
     "\xd0\x8e",
     "\xd1\x9e",
     "\xd0\x8f",
     "\xd1\x9f",
     "\xe2\x84\x96",
     "\xd0\x81",
     "\xd1\x91",
     "\xd1\x8f",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd0\xb2",
     "\xd0\xb3",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd0\xb6",
     "\xd0\xb7",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd1\x84",
     "\xd1\x85",
     "\xd1\x86",
     "\xd1\x87",
     "\xd1\x88",
     "\xd1\x89",
     "\xd1\x8a",
     "\xd1\x8b",
     "\xd1\x8c",
     "\xd1\x8d",
     "\xd1\x8e",
     "\xc2\xa4",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xff",
     0x000000a7 => "\xa4",
     0x000000a9 => "\xa9",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ae => "\xa8",
     0x000000b0 => "\xa1",
     0x000000b1 => "\xb1",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xa6",
     0x000000bb => "\xc8",
     0x000000f7 => "\xd6",
     0x00000192 => "\xc4",
     0x00000401 => "\xdd",
     0x00000402 => "\xab",
     0x00000403 => "\xae",
     0x00000404 => "\xb8",
     0x00000405 => "\xc1",
     0x00000406 => "\xa7",
     0x00000407 => "\xba",
     0x00000408 => "\xb7",
     0x00000409 => "\xbc",
     0x0000040a => "\xbe",
     0x0000040b => "\xcb",
     0x0000040c => "\xcd",
     0x0000040e => "\xd8",
     0x0000040f => "\xda",
     0x00000410 => "\x80",
     0x00000411 => "\x81",
     0x00000412 => "\x82",
     0x00000413 => "\x83",
     0x00000414 => "\x84",
     0x00000415 => "\x85",
     0x00000416 => "\x86",
     0x00000417 => "\x87",
     0x00000418 => "\x88",
     0x00000419 => "\x89",
     0x0000041a => "\x8a",
     0x0000041b => "\x8b",
     0x0000041c => "\x8c",
     0x0000041d => "\x8d",
     0x0000041e => "\x8e",
     0x0000041f => "\x8f",
     0x00000420 => "\x90",
     0x00000421 => "\x91",
     0x00000422 => "\x92",
     0x00000423 => "\x93",
     0x00000424 => "\x94",
     0x00000425 => "\x95",
     0x00000426 => "\x96",
     0x00000427 => "\x97",
     0x00000428 => "\x98",
     0x00000429 => "\x99",
     0x0000042a => "\x9a",
     0x0000042b => "\x9b",
     0x0000042c => "\x9c",
     0x0000042d => "\x9d",
     0x0000042e => "\x9e",
     0x0000042f => "\x9f",
     0x00000430 => "\xe0",
     0x00000431 => "\xe1",
     0x00000432 => "\xe2",
     0x00000433 => "\xe3",
     0x00000434 => "\xe4",
     0x00000435 => "\xe5",
     0x00000436 => "\xe6",
     0x00000437 => "\xe7",
     0x00000438 => "\xe8",
     0x00000439 => "\xe9",
     0x0000043a => "\xea",
     0x0000043b => "\xeb",
     0x0000043c => "\xec",
     0x0000043d => "\xed",
     0x0000043e => "\xee",
     0x0000043f => "\xef",
     0x00000440 => "\xf0",
     0x00000441 => "\xf1",
     0x00000442 => "\xf2",
     0x00000443 => "\xf3",
     0x00000444 => "\xf4",
     0x00000445 => "\xf5",
     0x00000446 => "\xf6",
     0x00000447 => "\xf7",
     0x00000448 => "\xf8",
     0x00000449 => "\xf9",
     0x0000044a => "\xfa",
     0x0000044b => "\xfb",
     0x0000044c => "\xfc",
     0x0000044d => "\xfd",
     0x0000044e => "\xfe",
     0x0000044f => "\xdf",
     0x00000451 => "\xde",
     0x00000452 => "\xac",
     0x00000453 => "\xaf",
     0x00000454 => "\xb9",
     0x00000455 => "\xcf",
     0x00000456 => "\xb4",
     0x00000457 => "\xbb",
     0x00000458 => "\xc0",
     0x00000459 => "\xbd",
     0x0000045a => "\xbf",
     0x0000045b => "\xcc",
     0x0000045c => "\xce",
     0x0000045e => "\xd9",
     0x0000045f => "\xdb",
     0x00000490 => "\xa2",
     0x00000491 => "\xb6",
     0x00002013 => "\xd0",
     0x00002014 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xd7",
     0x00002020 => "\xa0",
     0x00002022 => "\xa5",
     0x00002026 => "\xc9",
     0x00002116 => "\xdc",
     0x00002122 => "\xaa",
     0x00002206 => "\xc6",
     0x0000221a => "\xc3",
     0x0000221e => "\xb0",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x00002264 => "\xb2",
     0x00002265 => "\xb3",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MAC_IS.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MAC_IS;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c4,
     0x00c5,
     0x00c7,
     0x00c9,
     0x00d1,
     0x00d6,
     0x00dc,
     0x00e1,
     0x00e0,
     0x00e2,
     0x00e4,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00e9,
     0x00e8,
     0x00ea,
     0x00eb,
     0x00ed,
     0x00ec,
     0x00ee,
     0x00ef,
     0x00f1,
     0x00f3,
     0x00f2,
     0x00f4,
     0x00f6,
     0x00f5,
     0x00fa,
     0x00f9,
     0x00fb,
     0x00fc,
     0x2020,
     0x00b0,
     0x00a2,
     0x00a3,
     0x00a7,
     0x2022,
     0x00b6,
     0x00df,
     0x00ae,
     0x00a9,
     0x2122,
     0x00b4,
     0x00a8,
     0x2260,
     0x00c6,
     0x00d8,
     0x221e,
     0x00b1,
     0x2264,
     0x2265,
     0x00a5,
     0x00b5,
     0x2202,
     0x2211,
     0x220f,
     0x03c0,
     0x222b,
     0x00aa,
     0x00ba,
     0x03a9,
     0x00e6,
     0x00f8,
     0x00bf,
     0x00a1,
     0x00ac,
     0x221a,
     0x0192,
     0x2248,
     0x0394,
     0x00ab,
     0x00bb,
     0x2026,
     0x00a0,
     0x00c0,
     0x00c3,
     0x00d5,
     0x0152,
     0x0153,
     0x2014,
     0x2013,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x25c6,
     0x00ff,
     0x0178,
     0x2044,
     0x00a4,
     0x0110,
     0x0111,
     0x00de,
     0x00fe,
     0x2021,
     0x00b7,
     0x201a,
     0x201e,
     0x2030,
     0x00c2,
     0x00ca,
     0x00c1,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x00d3,
     0x00d4,
     0xe01e,
     0x00d2,
     0x00da,
     0x00db,
     0x00d9,
     0x0131,
     0xfffd,
     0xfffd,
     0x00af,
     0x02d8,
     0x02d9,
     0x02da,
     0x00b8,
     0x02dd,
     0x02db,
     0x02c7,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x89",
     "\xc3\x91",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xa1",
     "\xc3\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xa9",
     "\xc3\xa8",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xad",
     "\xc3\xac",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb1",
     "\xc3\xb3",
     "\xc3\xb2",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb5",
     "\xc3\xba",
     "\xc3\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xe2\x80\xa0",
     "\xc2\xb0",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xc2\xa7",
     "\xe2\x80\xa2",
     "\xc2\xb6",
     "\xc3\x9f",
     "\xc2\xae",
     "\xc2\xa9",
     "\xe2\x84\xa2",
     "\xc2\xb4",
     "\xc2\xa8",
     "\xe2\x89\xa0",
     "\xc3\x86",
     "\xc3\x98",
     "\xe2\x88\x9e",
     "\xc2\xb1",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xc2\xa5",
     "\xc2\xb5",
     "\xe2\x88\x82",
     "\xe2\x88\x91",
     "\xe2\x88\x8f",
     "\xcf\x80",
     "\xe2\x88\xab",
     "\xc2\xaa",
     "\xc2\xba",
     "\xce\xa9",
     "\xc3\xa6",
     "\xc3\xb8",
     "\xc2\xbf",
     "\xc2\xa1",
     "\xc2\xac",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x89\x88",
     "\xce\x94",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xc3\x80",
     "\xc3\x83",
     "\xc3\x95",
     "\xc5\x92",
     "\xc5\x93",
     "\xe2\x80\x94",
     "\xe2\x80\x93",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xe2\x97\x86",
     "\xc3\xbf",
     "\xc5\xb8",
     "\xe2\x81\x84",
     "\xc2\xa4",
     "\xc4\x90",
     "\xc4\x91",
     "\xc3\x9e",
     "\xc3\xbe",
     "\xe2\x80\xa1",
     "\xc2\xb7",
     "\xe2\x80\x9a",
     "\xe2\x80\x9e",
     "\xe2\x80\xb0",
     "\xc3\x82",
     "\xc3\x8a",
     "\xc3\x81",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc3\x93",
     "\xc3\x94",
     "\xee\x80\x9e",
     "\xc3\x92",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x99",
     "\xc4\xb1",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc2\xaf",
     "\xcb\x98",
     "\xcb\x99",
     "\xcb\x9a",
     "\xc2\xb8",
     "\xcb\x9d",
     "\xcb\x9b",
     "\xcb\x87",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a1 => "\xc1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xdb",
     0x000000a5 => "\xb4",
     0x000000a7 => "\xa4",
     0x000000a8 => "\xac",
     0x000000a9 => "\xa9",
     0x000000aa => "\xbb",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ae => "\xa8",
     0x000000af => "\xf8",
     0x000000b0 => "\xa1",
     0x000000b1 => "\xb1",
     0x000000b4 => "\xab",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xa6",
     0x000000b7 => "\xe1",
     0x000000b8 => "\xfc",
     0x000000ba => "\xbc",
     0x000000bb => "\xc8",
     0x000000bf => "\xc0",
     0x000000c0 => "\xcb",
     0x000000c1 => "\xe7",
     0x000000c2 => "\xe5",
     0x000000c3 => "\xcc",
     0x000000c4 => "\x80",
     0x000000c5 => "\x81",
     0x000000c6 => "\xae",
     0x000000c7 => "\x82",
     0x000000c8 => "\xe9",
     0x000000c9 => "\x83",
     0x000000ca => "\xe6",
     0x000000cb => "\xe8",
     0x000000cc => "\xed",
     0x000000cd => "\xea",
     0x000000ce => "\xeb",
     0x000000cf => "\xec",
     0x000000d1 => "\x84",
     0x000000d2 => "\xf1",
     0x000000d3 => "\xee",
     0x000000d4 => "\xef",
     0x000000d5 => "\xcd",
     0x000000d6 => "\x85",
     0x000000d8 => "\xaf",
     0x000000d9 => "\xf4",
     0x000000da => "\xf2",
     0x000000db => "\xf3",
     0x000000dc => "\x86",
     0x000000de => "\xde",
     0x000000df => "\xa7",
     0x000000e0 => "\x88",
     0x000000e1 => "\x87",
     0x000000e2 => "\x89",
     0x000000e3 => "\x8b",
     0x000000e4 => "\x8a",
     0x000000e5 => "\x8c",
     0x000000e6 => "\xbe",
     0x000000e7 => "\x8d",
     0x000000e8 => "\x8f",
     0x000000e9 => "\x8e",
     0x000000ea => "\x90",
     0x000000eb => "\x91",
     0x000000ec => "\x93",
     0x000000ed => "\x92",
     0x000000ee => "\x94",
     0x000000ef => "\x95",
     0x000000f1 => "\x96",
     0x000000f2 => "\x98",
     0x000000f3 => "\x97",
     0x000000f4 => "\x99",
     0x000000f5 => "\x9b",
     0x000000f6 => "\x9a",
     0x000000f7 => "\xd6",
     0x000000f8 => "\xbf",
     0x000000f9 => "\x9d",
     0x000000fa => "\x9c",
     0x000000fb => "\x9e",
     0x000000fc => "\x9f",
     0x000000fe => "\xdf",
     0x000000ff => "\xd8",
     0x00000110 => "\xdc",
     0x00000111 => "\xdd",
     0x00000131 => "\xf5",
     0x00000152 => "\xce",
     0x00000153 => "\xcf",
     0x00000178 => "\xd9",
     0x00000192 => "\xc4",
     0x000002c7 => "\xff",
     0x000002d8 => "\xf9",
     0x000002d9 => "\xfa",
     0x000002da => "\xfb",
     0x000002db => "\xfe",
     0x000002dd => "\xfd",
     0x00000394 => "\xc6",
     0x000003a9 => "\xbd",
     0x000003c0 => "\xb9",
     0x00002013 => "\xd1",
     0x00002014 => "\xd0",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201a => "\xe2",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xe3",
     0x00002020 => "\xa0",
     0x00002021 => "\xe0",
     0x00002022 => "\xa5",
     0x00002026 => "\xc9",
     0x00002030 => "\xe4",
     0x00002044 => "\xda",
     0x00002122 => "\xaa",
     0x00002202 => "\xb6",
     0x0000220f => "\xb8",
     0x00002211 => "\xb7",
     0x0000221a => "\xc3",
     0x0000221e => "\xb0",
     0x0000222b => "\xba",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x00002264 => "\xb2",
     0x00002265 => "\xb3",
     0x000025c6 => "\xd7",
     0x0000e01e => "\xf0",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MAC_SAMI.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MAC_SAMI;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00c4,
     0x00c5,
     0x00c7,
     0x00c9,
     0x00d1,
     0x00d6,
     0x00dc,
     0x00e1,
     0x00e0,
     0x00e2,
     0x00e4,
     0x00e3,
     0x00e5,
     0x00e7,
     0x00e9,
     0x00e8,
     0x00ea,
     0x00eb,
     0x00ed,
     0x00ec,
     0x00ee,
     0x00ef,
     0x00f1,
     0x00f3,
     0x00f2,
     0x00f4,
     0x00f6,
     0x00f5,
     0x00fa,
     0x00f9,
     0x00fb,
     0x00fc,
     0x00dd,
     0x00b0,
     0x010c,
     0x00a3,
     0x00a7,
     0x2022,
     0x00b6,
     0x00df,
     0x00ae,
     0x00a9,
     0x2122,
     0x00b4,
     0x00a8,
     0x2260,
     0x00c6,
     0x00d8,
     0x0110,
     0x014a,
     0x821e,
     0x821f,
     0x0160,
     0x0166,
     0x2202,
     0x017d,
     0x010d,
     0x0111,
     0x014b,
     0x0161,
     0x0167,
     0x017e,
     0x00e6,
     0x00f8,
     0x00bf,
     0x00a1,
     0x00ac,
     0x221a,
     0x0192,
     0x2248,
     0x2206,
     0x00ab,
     0x00bb,
     0x2026,
     0x00a0,
     0x00c0,
     0x00c3,
     0x00d5,
     0x0152,
     0x0153,
     0x2013,
     0x2014,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x25ca,
     0x00ff,
     0x0178,
     0x2044,
     0x00a4,
     0x00d0,
     0x00f0,
     0x00de,
     0x00fe,
     0x00fd,
     0x00b7,
     0x201a,
     0x201e,
     0x2030,
     0x00c2,
     0x00ca,
     0x00c1,
     0x00cb,
     0x00c8,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00cc,
     0x00d3,
     0x00d4,
     0xf8ff,
     0x00d2,
     0x00da,
     0x00db,
     0x00d9,
     0x0131,
     0x01b7,
     0x0292,
     0x01ee,
     0x01ef,
     0x01e4,
     0x01e5,
     0x01e6,
     0x01e7,
     0x01e8,
     0x01e9,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x89",
     "\xc3\x91",
     "\xc3\x96",
     "\xc3\x9c",
     "\xc3\xa1",
     "\xc3\xa0",
     "\xc3\xa2",
     "\xc3\xa4",
     "\xc3\xa3",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xa9",
     "\xc3\xa8",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xad",
     "\xc3\xac",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb1",
     "\xc3\xb3",
     "\xc3\xb2",
     "\xc3\xb4",
     "\xc3\xb6",
     "\xc3\xb5",
     "\xc3\xba",
     "\xc3\xb9",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\x9d",
     "\xc2\xb0",
     "\xc4\x8c",
     "\xc2\xa3",
     "\xc2\xa7",
     "\xe2\x80\xa2",
     "\xc2\xb6",
     "\xc3\x9f",
     "\xc2\xae",
     "\xc2\xa9",
     "\xe2\x84\xa2",
     "\xc2\xb4",
     "\xc2\xa8",
     "\xe2\x89\xa0",
     "\xc3\x86",
     "\xc3\x98",
     "\xc4\x90",
     "\xc5\x8a",
     "\xe8\x88\x9e",
     "\xe8\x88\x9f",
     "\xc5\xa0",
     "\xc5\xa6",
     "\xe2\x88\x82",
     "\xc5\xbd",
     "\xc4\x8d",
     "\xc4\x91",
     "\xc5\x8b",
     "\xc5\xa1",
     "\xc5\xa7",
     "\xc5\xbe",
     "\xc3\xa6",
     "\xc3\xb8",
     "\xc2\xbf",
     "\xc2\xa1",
     "\xc2\xac",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x89\x88",
     "\xe2\x88\x86",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xc3\x80",
     "\xc3\x83",
     "\xc3\x95",
     "\xc5\x92",
     "\xc5\x93",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xe2\x97\x8a",
     "\xc3\xbf",
     "\xc5\xb8",
     "\xe2\x81\x84",
     "\xc2\xa4",
     "\xc3\x90",
     "\xc3\xb0",
     "\xc3\x9e",
     "\xc3\xbe",
     "\xc3\xbd",
     "\xc2\xb7",
     "\xe2\x80\x9a",
     "\xe2\x80\x9e",
     "\xe2\x80\xb0",
     "\xc3\x82",
     "\xc3\x8a",
     "\xc3\x81",
     "\xc3\x8b",
     "\xc3\x88",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x8c",
     "\xc3\x93",
     "\xc3\x94",
     "\xef\xa3\xbf",
     "\xc3\x92",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x99",
     "\xc4\xb1",
     "\xc6\xb7",
     "\xca\x92",
     "\xc7\xae",
     "\xc7\xaf",
     "\xc7\xa4",
     "\xc7\xa5",
     "\xc7\xa6",
     "\xc7\xa7",
     "\xc7\xa8",
     "\xc7\xa9",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a1 => "\xc1",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xdb",
     0x000000a7 => "\xa4",
     0x000000a8 => "\xac",
     0x000000a9 => "\xa9",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ae => "\xa8",
     0x000000b0 => "\xa1",
     0x000000b4 => "\xab",
     0x000000b6 => "\xa6",
     0x000000b7 => "\xe1",
     0x000000bb => "\xc8",
     0x000000bf => "\xc0",
     0x000000c0 => "\xcb",
     0x000000c1 => "\xe7",
     0x000000c2 => "\xe5",
     0x000000c3 => "\xcc",
     0x000000c4 => "\x80",
     0x000000c5 => "\x81",
     0x000000c6 => "\xae",
     0x000000c7 => "\x82",
     0x000000c8 => "\xe9",
     0x000000c9 => "\x83",
     0x000000ca => "\xe6",
     0x000000cb => "\xe8",
     0x000000cc => "\xed",
     0x000000cd => "\xea",
     0x000000ce => "\xeb",
     0x000000cf => "\xec",
     0x000000d0 => "\xdc",
     0x000000d1 => "\x84",
     0x000000d2 => "\xf1",
     0x000000d3 => "\xee",
     0x000000d4 => "\xef",
     0x000000d5 => "\xcd",
     0x000000d6 => "\x85",
     0x000000d8 => "\xaf",
     0x000000d9 => "\xf4",
     0x000000da => "\xf2",
     0x000000db => "\xf3",
     0x000000dc => "\x86",
     0x000000dd => "\xa0",
     0x000000de => "\xde",
     0x000000df => "\xa7",
     0x000000e0 => "\x88",
     0x000000e1 => "\x87",
     0x000000e2 => "\x89",
     0x000000e3 => "\x8b",
     0x000000e4 => "\x8a",
     0x000000e5 => "\x8c",
     0x000000e6 => "\xbe",
     0x000000e7 => "\x8d",
     0x000000e8 => "\x8f",
     0x000000e9 => "\x8e",
     0x000000ea => "\x90",
     0x000000eb => "\x91",
     0x000000ec => "\x93",
     0x000000ed => "\x92",
     0x000000ee => "\x94",
     0x000000ef => "\x95",
     0x000000f0 => "\xdd",
     0x000000f1 => "\x96",
     0x000000f2 => "\x98",
     0x000000f3 => "\x97",
     0x000000f4 => "\x99",
     0x000000f5 => "\x9b",
     0x000000f6 => "\x9a",
     0x000000f7 => "\xd6",
     0x000000f8 => "\xbf",
     0x000000f9 => "\x9d",
     0x000000fa => "\x9c",
     0x000000fb => "\x9e",
     0x000000fc => "\x9f",
     0x000000fd => "\xe0",
     0x000000fe => "\xdf",
     0x000000ff => "\xd8",
     0x0000010c => "\xa2",
     0x0000010d => "\xb8",
     0x00000110 => "\xb0",
     0x00000111 => "\xb9",
     0x00000131 => "\xf5",
     0x0000014a => "\xb1",
     0x0000014b => "\xba",
     0x00000152 => "\xce",
     0x00000153 => "\xcf",
     0x00000160 => "\xb4",
     0x00000161 => "\xbb",
     0x00000166 => "\xb5",
     0x00000167 => "\xbc",
     0x00000178 => "\xd9",
     0x0000017d => "\xb7",
     0x0000017e => "\xbd",
     0x00000192 => "\xc4",
     0x000001b7 => "\xf6",
     0x000001e4 => "\xfa",
     0x000001e5 => "\xfb",
     0x000001e6 => "\xfc",
     0x000001e7 => "\xfd",
     0x000001e8 => "\xfe",
     0x000001e9 => "\xff",
     0x000001ee => "\xf8",
     0x000001ef => "\xf9",
     0x00000292 => "\xf7",
     0x00002013 => "\xd0",
     0x00002014 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201a => "\xe2",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xe3",
     0x00002022 => "\xa5",
     0x00002026 => "\xc9",
     0x00002030 => "\xe4",
     0x00002044 => "\xda",
     0x00002122 => "\xaa",
     0x00002202 => "\xb6",
     0x00002206 => "\xc6",
     0x0000221a => "\xc3",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x000025ca => "\xd7",
     0x0000821e => "\xb2",
     0x0000821f => "\xb3",
     0x0000f8ff => "\xf0",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/MAC_UK.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::MAC_UK;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x0410,
     0x0411,
     0x0412,
     0x0413,
     0x0414,
     0x0415,
     0x0416,
     0x0417,
     0x0418,
     0x0419,
     0x041a,
     0x041b,
     0x041c,
     0x041d,
     0x041e,
     0x041f,
     0x0420,
     0x0421,
     0x0422,
     0x0423,
     0x0424,
     0x0425,
     0x0426,
     0x0427,
     0x0428,
     0x0429,
     0x042a,
     0x042b,
     0x042c,
     0x042d,
     0x042e,
     0x042f,
     0x2020,
     0x00b0,
     0x0490,
     0x00a3,
     0x00a7,
     0x2022,
     0x00b6,
     0x0406,
     0x00ae,
     0x00a9,
     0x2122,
     0x0402,
     0x0452,
     0x2260,
     0x0403,
     0x0453,
     0x221e,
     0x00b1,
     0x2264,
     0x2265,
     0x0456,
     0x00b5,
     0x0491,
     0x0408,
     0x0404,
     0x0454,
     0x0407,
     0x0457,
     0x0409,
     0x0459,
     0x040a,
     0x045a,
     0x0458,
     0x0405,
     0x00ac,
     0x221a,
     0x0192,
     0x2248,
     0x2206,
     0x00ab,
     0x00bb,
     0x2026,
     0x00a0,
     0x040b,
     0x045b,
     0x040c,
     0x045c,
     0x0455,
     0x2013,
     0x2014,
     0x201c,
     0x201d,
     0x2018,
     0x2019,
     0x00f7,
     0x201e,
     0x040e,
     0x045e,
     0x040f,
     0x045f,
     0x2116,
     0x0401,
     0x0451,
     0x044f,
     0x0430,
     0x0431,
     0x0432,
     0x0433,
     0x0434,
     0x0435,
     0x0436,
     0x0437,
     0x0438,
     0x0439,
     0x043a,
     0x043b,
     0x043c,
     0x043d,
     0x043e,
     0x043f,
     0x0440,
     0x0441,
     0x0442,
     0x0443,
     0x0444,
     0x0445,
     0x0446,
     0x0447,
     0x0448,
     0x0449,
     0x044a,
     0x044b,
     0x044c,
     0x044d,
     0x044e,
     0x00a4,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xd0\x90",
     "\xd0\x91",
     "\xd0\x92",
     "\xd0\x93",
     "\xd0\x94",
     "\xd0\x95",
     "\xd0\x96",
     "\xd0\x97",
     "\xd0\x98",
     "\xd0\x99",
     "\xd0\x9a",
     "\xd0\x9b",
     "\xd0\x9c",
     "\xd0\x9d",
     "\xd0\x9e",
     "\xd0\x9f",
     "\xd0\xa0",
     "\xd0\xa1",
     "\xd0\xa2",
     "\xd0\xa3",
     "\xd0\xa4",
     "\xd0\xa5",
     "\xd0\xa6",
     "\xd0\xa7",
     "\xd0\xa8",
     "\xd0\xa9",
     "\xd0\xaa",
     "\xd0\xab",
     "\xd0\xac",
     "\xd0\xad",
     "\xd0\xae",
     "\xd0\xaf",
     "\xe2\x80\xa0",
     "\xc2\xb0",
     "\xd2\x90",
     "\xc2\xa3",
     "\xc2\xa7",
     "\xe2\x80\xa2",
     "\xc2\xb6",
     "\xd0\x86",
     "\xc2\xae",
     "\xc2\xa9",
     "\xe2\x84\xa2",
     "\xd0\x82",
     "\xd1\x92",
     "\xe2\x89\xa0",
     "\xd0\x83",
     "\xd1\x93",
     "\xe2\x88\x9e",
     "\xc2\xb1",
     "\xe2\x89\xa4",
     "\xe2\x89\xa5",
     "\xd1\x96",
     "\xc2\xb5",
     "\xd2\x91",
     "\xd0\x88",
     "\xd0\x84",
     "\xd1\x94",
     "\xd0\x87",
     "\xd1\x97",
     "\xd0\x89",
     "\xd1\x99",
     "\xd0\x8a",
     "\xd1\x9a",
     "\xd1\x98",
     "\xd0\x85",
     "\xc2\xac",
     "\xe2\x88\x9a",
     "\xc6\x92",
     "\xe2\x89\x88",
     "\xe2\x88\x86",
     "\xc2\xab",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xc2\xa0",
     "\xd0\x8b",
     "\xd1\x9b",
     "\xd0\x8c",
     "\xd1\x9c",
     "\xd1\x95",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xc3\xb7",
     "\xe2\x80\x9e",
     "\xd0\x8e",
     "\xd1\x9e",
     "\xd0\x8f",
     "\xd1\x9f",
     "\xe2\x84\x96",
     "\xd0\x81",
     "\xd1\x91",
     "\xd1\x8f",
     "\xd0\xb0",
     "\xd0\xb1",
     "\xd0\xb2",
     "\xd0\xb3",
     "\xd0\xb4",
     "\xd0\xb5",
     "\xd0\xb6",
     "\xd0\xb7",
     "\xd0\xb8",
     "\xd0\xb9",
     "\xd0\xba",
     "\xd0\xbb",
     "\xd0\xbc",
     "\xd0\xbd",
     "\xd0\xbe",
     "\xd0\xbf",
     "\xd1\x80",
     "\xd1\x81",
     "\xd1\x82",
     "\xd1\x83",
     "\xd1\x84",
     "\xd1\x85",
     "\xd1\x86",
     "\xd1\x87",
     "\xd1\x88",
     "\xd1\x89",
     "\xd1\x8a",
     "\xd1\x8b",
     "\xd1\x8c",
     "\xd1\x8d",
     "\xd1\x8e",
     "\xc2\xa4",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xca",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xff",
     0x000000a7 => "\xa4",
     0x000000a9 => "\xa9",
     0x000000ab => "\xc7",
     0x000000ac => "\xc2",
     0x000000ae => "\xa8",
     0x000000b0 => "\xa1",
     0x000000b1 => "\xb1",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xa6",
     0x000000bb => "\xc8",
     0x000000f7 => "\xd6",
     0x00000192 => "\xc4",
     0x00000401 => "\xdd",
     0x00000402 => "\xab",
     0x00000403 => "\xae",
     0x00000404 => "\xb8",
     0x00000405 => "\xc1",
     0x00000406 => "\xa7",
     0x00000407 => "\xba",
     0x00000408 => "\xb7",
     0x00000409 => "\xbc",
     0x0000040a => "\xbe",
     0x0000040b => "\xcb",
     0x0000040c => "\xcd",
     0x0000040e => "\xd8",
     0x0000040f => "\xda",
     0x00000410 => "\x80",
     0x00000411 => "\x81",
     0x00000412 => "\x82",
     0x00000413 => "\x83",
     0x00000414 => "\x84",
     0x00000415 => "\x85",
     0x00000416 => "\x86",
     0x00000417 => "\x87",
     0x00000418 => "\x88",
     0x00000419 => "\x89",
     0x0000041a => "\x8a",
     0x0000041b => "\x8b",
     0x0000041c => "\x8c",
     0x0000041d => "\x8d",
     0x0000041e => "\x8e",
     0x0000041f => "\x8f",
     0x00000420 => "\x90",
     0x00000421 => "\x91",
     0x00000422 => "\x92",
     0x00000423 => "\x93",
     0x00000424 => "\x94",
     0x00000425 => "\x95",
     0x00000426 => "\x96",
     0x00000427 => "\x97",
     0x00000428 => "\x98",
     0x00000429 => "\x99",
     0x0000042a => "\x9a",
     0x0000042b => "\x9b",
     0x0000042c => "\x9c",
     0x0000042d => "\x9d",
     0x0000042e => "\x9e",
     0x0000042f => "\x9f",
     0x00000430 => "\xe0",
     0x00000431 => "\xe1",
     0x00000432 => "\xe2",
     0x00000433 => "\xe3",
     0x00000434 => "\xe4",
     0x00000435 => "\xe5",
     0x00000436 => "\xe6",
     0x00000437 => "\xe7",
     0x00000438 => "\xe8",
     0x00000439 => "\xe9",
     0x0000043a => "\xea",
     0x0000043b => "\xeb",
     0x0000043c => "\xec",
     0x0000043d => "\xed",
     0x0000043e => "\xee",
     0x0000043f => "\xef",
     0x00000440 => "\xf0",
     0x00000441 => "\xf1",
     0x00000442 => "\xf2",
     0x00000443 => "\xf3",
     0x00000444 => "\xf4",
     0x00000445 => "\xf5",
     0x00000446 => "\xf6",
     0x00000447 => "\xf7",
     0x00000448 => "\xf8",
     0x00000449 => "\xf9",
     0x0000044a => "\xfa",
     0x0000044b => "\xfb",
     0x0000044c => "\xfc",
     0x0000044d => "\xfd",
     0x0000044e => "\xfe",
     0x0000044f => "\xdf",
     0x00000451 => "\xde",
     0x00000452 => "\xac",
     0x00000453 => "\xaf",
     0x00000454 => "\xb9",
     0x00000455 => "\xcf",
     0x00000456 => "\xb4",
     0x00000457 => "\xbb",
     0x00000458 => "\xc0",
     0x00000459 => "\xbd",
     0x0000045a => "\xbf",
     0x0000045b => "\xcc",
     0x0000045c => "\xce",
     0x0000045e => "\xd9",
     0x0000045f => "\xdb",
     0x00000490 => "\xa2",
     0x00000491 => "\xb6",
     0x00002013 => "\xd0",
     0x00002014 => "\xd1",
     0x00002018 => "\xd4",
     0x00002019 => "\xd5",
     0x0000201c => "\xd2",
     0x0000201d => "\xd3",
     0x0000201e => "\xd7",
     0x00002020 => "\xa0",
     0x00002022 => "\xa5",
     0x00002026 => "\xc9",
     0x00002116 => "\xdc",
     0x00002122 => "\xaa",
     0x00002206 => "\xc6",
     0x0000221a => "\xc3",
     0x0000221e => "\xb0",
     0x00002248 => "\xc5",
     0x00002260 => "\xad",
     0x00002264 => "\xb2",
     0x00002265 => "\xb3",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/NATS_DANO.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::NATS_DANO;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x00ab,
     0x00bb,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0xe018,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00c6,
     0x00d8,
     0x00c5,
     0x25a0,
     0x005f,
     0xe019,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00e6,
     0x00f8,
     0x00e5,
     0x2013,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\xc2\xab",
     "\xc2\xbb",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\xee\x80\x98",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc3\x86",
     "\xc3\x98",
     "\xc3\x85",
     "\xe2\x96\xa0",
     "\x5f",
     "\xee\x80\x99",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc3\xa6",
     "\xc3\xb8",
     "\xc3\xa5",
     "\xe2\x80\x93",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005f => "\x5f",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007f => "\x7f",
     0x000000ab => "\x22",
     0x000000bb => "\x23",
     0x000000c5 => "\x5d",
     0x000000c6 => "\x5b",
     0x000000d8 => "\x5c",
     0x000000e5 => "\x7d",
     0x000000e6 => "\x7b",
     0x000000f8 => "\x7c",
     0x00002013 => "\x7e",
     0x000025a0 => "\x5e",
     0x0000e018 => "\x40",
     0x0000e019 => "\x60",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/NATS_SEFI.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::NATS_SEFI;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0xe018,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x00c4,
     0x00d6,
     0x00c5,
     0x25a0,
     0x005f,
     0xe019,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x00e4,
     0x00f6,
     0x00e5,
     0x2013,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\xee\x80\x98",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\xc3\x84",
     "\xc3\x96",
     "\xc3\x85",
     "\xe2\x96\xa0",
     "\x5f",
     "\xee\x80\x99",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\xc3\xa4",
     "\xc3\xb6",
     "\xc3\xa5",
     "\xe2\x80\x93",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005f => "\x5f",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007f => "\x7f",
     0x000000c4 => "\x5b",
     0x000000c5 => "\x5d",
     0x000000d6 => "\x5c",
     0x000000e4 => "\x7b",
     0x000000e5 => "\x7d",
     0x000000f6 => "\x7c",
     0x00002013 => "\x7e",
     0x000025a0 => "\x5e",
     0x0000e018 => "\x40",
     0x0000e019 => "\x60",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/NEXTSTEP.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::NEXTSTEP;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x00a0,
     0x00c0,
     0x00c1,
     0x00c2,
     0x00c3,
     0x00c4,
     0x00c5,
     0x00c7,
     0x00c8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00cc,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00d0,
     0x00d1,
     0x00d2,
     0x00d3,
     0x00d4,
     0x00d5,
     0x00d6,
     0x00d9,
     0x00da,
     0x00db,
     0x00dc,
     0x00dd,
     0x00de,
     0x00b5,
     0x00d7,
     0x00f7,
     0x00a9,
     0x00a1,
     0x00a2,
     0x00a3,
     0x2044,
     0x00a5,
     0x0192,
     0x00a7,
     0x00a4,
     0x2019,
     0x201c,
     0x00ab,
     0x2039,
     0x203a,
     0xfb01,
     0xfb02,
     0x00ae,
     0x2013,
     0x2020,
     0x2021,
     0x00b7,
     0x00a6,
     0x00b6,
     0x2022,
     0x201a,
     0x201e,
     0x201d,
     0x00bb,
     0x2026,
     0x2030,
     0x00ac,
     0x00bf,
     0x00b9,
     0x02cb,
     0x00b4,
     0x02c6,
     0x02dc,
     0x00af,
     0x02d8,
     0x02d9,
     0x00a8,
     0x00b2,
     0x02da,
     0x00b8,
     0x00b3,
     0x02dd,
     0x02db,
     0x02c7,
     0x2014,
     0x00b1,
     0x00bc,
     0x00bd,
     0x00be,
     0x00e0,
     0x00e1,
     0x00e2,
     0x00e3,
     0x00e4,
     0x00e5,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00c6,
     0x00ed,
     0x00aa,
     0x00ee,
     0x00ef,
     0x00f0,
     0x00f1,
     0x0141,
     0x00d8,
     0x0152,
     0x00ba,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x00e6,
     0x00f9,
     0x00fa,
     0x00fb,
     0x0131,
     0x00fc,
     0x00fd,
     0x0142,
     0x00f8,
     0x0153,
     0x00df,
     0x00fe,
     0x00ff,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xc2\xa0",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x90",
     "\xc3\x91",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc2\xb5",
     "\xc3\x97",
     "\xc3\xb7",
     "\xc2\xa9",
     "\xc2\xa1",
     "\xc2\xa2",
     "\xc2\xa3",
     "\xe2\x81\x84",
     "\xc2\xa5",
     "\xc6\x92",
     "\xc2\xa7",
     "\xc2\xa4",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xc2\xab",
     "\xe2\x80\xb9",
     "\xe2\x80\xba",
     "\xef\xac\x81",
     "\xef\xac\x82",
     "\xc2\xae",
     "\xe2\x80\x93",
     "\xe2\x80\xa0",
     "\xe2\x80\xa1",
     "\xc2\xb7",
     "\xc2\xa6",
     "\xc2\xb6",
     "\xe2\x80\xa2",
     "\xe2\x80\x9a",
     "\xe2\x80\x9e",
     "\xe2\x80\x9d",
     "\xc2\xbb",
     "\xe2\x80\xa6",
     "\xe2\x80\xb0",
     "\xc2\xac",
     "\xc2\xbf",
     "\xc2\xb9",
     "\xcb\x8b",
     "\xc2\xb4",
     "\xcb\x86",
     "\xcb\x9c",
     "\xc2\xaf",
     "\xcb\x98",
     "\xcb\x99",
     "\xc2\xa8",
     "\xc2\xb2",
     "\xcb\x9a",
     "\xc2\xb8",
     "\xc2\xb3",
     "\xcb\x9d",
     "\xcb\x9b",
     "\xcb\x87",
     "\xe2\x80\x94",
     "\xc2\xb1",
     "\xc2\xbc",
     "\xc2\xbd",
     "\xc2\xbe",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\x86",
     "\xc3\xad",
     "\xc2\xaa",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb0",
     "\xc3\xb1",
     "\xc5\x81",
     "\xc3\x98",
     "\xc5\x92",
     "\xc2\xba",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xa6",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc4\xb1",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc5\x82",
     "\xc3\xb8",
     "\xc5\x93",
     "\xc3\x9f",
     "\xc3\xbe",
     "\xc3\xbf",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\x80",
     0x000000a1 => "\xa1",
     0x000000a2 => "\xa2",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa8",
     0x000000a5 => "\xa5",
     0x000000a6 => "\xb5",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xc8",
     0x000000a9 => "\xa0",
     0x000000aa => "\xe3",
     0x000000ab => "\xab",
     0x000000ac => "\xbe",
     0x000000ae => "\xb0",
     0x000000af => "\xc5",
     0x000000b1 => "\xd1",
     0x000000b2 => "\xc9",
     0x000000b3 => "\xcc",
     0x000000b4 => "\xc2",
     0x000000b5 => "\x9d",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb4",
     0x000000b8 => "\xcb",
     0x000000b9 => "\xc0",
     0x000000ba => "\xeb",
     0x000000bb => "\xbb",
     0x000000bc => "\xd2",
     0x000000bd => "\xd3",
     0x000000be => "\xd4",
     0x000000bf => "\xbf",
     0x000000c0 => "\x81",
     0x000000c1 => "\x82",
     0x000000c2 => "\x83",
     0x000000c3 => "\x84",
     0x000000c4 => "\x85",
     0x000000c5 => "\x86",
     0x000000c6 => "\xe1",
     0x000000c7 => "\x87",
     0x000000c8 => "\x88",
     0x000000c9 => "\x89",
     0x000000ca => "\x8a",
     0x000000cb => "\x8b",
     0x000000cc => "\x8c",
     0x000000cd => "\x8d",
     0x000000ce => "\x8e",
     0x000000cf => "\x8f",
     0x000000d0 => "\x90",
     0x000000d1 => "\x91",
     0x000000d2 => "\x92",
     0x000000d3 => "\x93",
     0x000000d4 => "\x94",
     0x000000d5 => "\x95",
     0x000000d6 => "\x96",
     0x000000d7 => "\x9e",
     0x000000d8 => "\xe9",
     0x000000d9 => "\x97",
     0x000000da => "\x98",
     0x000000db => "\x99",
     0x000000dc => "\x9a",
     0x000000dd => "\x9b",
     0x000000de => "\x9c",
     0x000000df => "\xfb",
     0x000000e0 => "\xd5",
     0x000000e1 => "\xd6",
     0x000000e2 => "\xd7",
     0x000000e3 => "\xd8",
     0x000000e4 => "\xd9",
     0x000000e5 => "\xda",
     0x000000e6 => "\xf1",
     0x000000e7 => "\xdb",
     0x000000e8 => "\xdc",
     0x000000e9 => "\xdd",
     0x000000ea => "\xde",
     0x000000eb => "\xdf",
     0x000000ec => "\xe0",
     0x000000ed => "\xe2",
     0x000000ee => "\xe4",
     0x000000ef => "\xe5",
     0x000000f0 => "\xe6",
     0x000000f1 => "\xe7",
     0x000000f2 => "\xec",
     0x000000f3 => "\xed",
     0x000000f4 => "\xee",
     0x000000f5 => "\xef",
     0x000000f6 => "\xf0",
     0x000000f7 => "\x9f",
     0x000000f8 => "\xf9",
     0x000000f9 => "\xf2",
     0x000000fa => "\xf3",
     0x000000fb => "\xf4",
     0x000000fc => "\xf6",
     0x000000fd => "\xf7",
     0x000000fe => "\xfc",
     0x000000ff => "\xfd",
     0x00000131 => "\xf5",
     0x00000141 => "\xe8",
     0x00000142 => "\xf8",
     0x00000152 => "\xea",
     0x00000153 => "\xfa",
     0x00000192 => "\xa6",
     0x000002c6 => "\xc3",
     0x000002c7 => "\xcf",
     0x000002cb => "\xc1",
     0x000002d8 => "\xc6",
     0x000002d9 => "\xc7",
     0x000002da => "\xca",
     0x000002db => "\xce",
     0x000002dc => "\xc4",
     0x000002dd => "\xcd",
     0x00002013 => "\xb1",
     0x00002014 => "\xd0",
     0x00002019 => "\xa9",
     0x0000201a => "\xb8",
     0x0000201c => "\xaa",
     0x0000201d => "\xba",
     0x0000201e => "\xb9",
     0x00002020 => "\xb2",
     0x00002021 => "\xb3",
     0x00002022 => "\xb7",
     0x00002026 => "\xbc",
     0x00002030 => "\xbd",
     0x00002039 => "\xac",
     0x0000203a => "\xad",
     0x00002044 => "\xa4",
     0x0000fb01 => "\xae",
     0x0000fb02 => "\xaf",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/SAMI_WS2.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::SAMI_WS2;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x20ac,
     0xfffd,
     0x010c,
     0x0192,
     0x010d,
     0x01b7,
     0x0292,
     0x01ee,
     0x01ef,
     0x0110,
     0x0160,
     0x2039,
     0x0152,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x2018,
     0x2019,
     0x201c,
     0x201d,
     0x2022,
     0x2013,
     0x2014,
     0x0111,
     0x01e6,
     0x0161,
     0x203a,
     0x0153,
     0xfffd,
     0xfffd,
     0x0178,
     0x00a0,
     0x01e7,
     0x01e4,
     0x00a3,
     0x00a4,
     0x01e5,
     0x00a6,
     0x00a7,
     0x00a8,
     0x00a9,
     0x021e,
     0x00ab,
     0x00ac,
     0x00ad,
     0x00ae,
     0x021f,
     0x00b0,
     0x00b1,
     0x01e8,
     0x01e9,
     0x00b4,
     0x00b5,
     0x00b6,
     0x00b7,
     0x014a,
     0x014b,
     0x0166,
     0x00bb,
     0x0167,
     0x00bd,
     0x017d,
     0x017e,
     0x00c0,
     0x00c1,
     0x00c2,
     0x00c3,
     0x00c4,
     0x00c5,
     0x00c6,
     0x00c7,
     0x00c8,
     0x00c9,
     0x00ca,
     0x00cb,
     0x00cc,
     0x00cd,
     0x00ce,
     0x00cf,
     0x00d0,
     0x00d1,
     0x00d2,
     0x00d3,
     0x00d4,
     0x00d5,
     0x00d6,
     0x00d7,
     0x00d8,
     0x00d9,
     0x00da,
     0x00db,
     0x00dc,
     0x00dd,
     0x00de,
     0x00df,
     0x00e0,
     0x00e1,
     0x00e2,
     0x00e3,
     0x00e4,
     0x00e5,
     0x00e6,
     0x00e7,
     0x00e8,
     0x00e9,
     0x00ea,
     0x00eb,
     0x00ec,
     0x00ed,
     0x00ee,
     0x00ef,
     0x00f0,
     0x00f1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x00f6,
     0x00f7,
     0x00f8,
     0x00f9,
     0x00fa,
     0x00fb,
     0x00fc,
     0x00fd,
     0x00fe,
     0x00ff,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe2\x82\xac",
     "\xef\xbf\xbd",
     "\xc4\x8c",
     "\xc6\x92",
     "\xc4\x8d",
     "\xc6\xb7",
     "\xca\x92",
     "\xc7\xae",
     "\xc7\xaf",
     "\xc4\x90",
     "\xc5\xa0",
     "\xe2\x80\xb9",
     "\xc5\x92",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe2\x80\x98",
     "\xe2\x80\x99",
     "\xe2\x80\x9c",
     "\xe2\x80\x9d",
     "\xe2\x80\xa2",
     "\xe2\x80\x93",
     "\xe2\x80\x94",
     "\xc4\x91",
     "\xc7\xa6",
     "\xc5\xa1",
     "\xe2\x80\xba",
     "\xc5\x93",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xc5\xb8",
     "\xc2\xa0",
     "\xc7\xa7",
     "\xc7\xa4",
     "\xc2\xa3",
     "\xc2\xa4",
     "\xc7\xa5",
     "\xc2\xa6",
     "\xc2\xa7",
     "\xc2\xa8",
     "\xc2\xa9",
     "\xc8\x9e",
     "\xc2\xab",
     "\xc2\xac",
     "\xc2\xad",
     "\xc2\xae",
     "\xc8\x9f",
     "\xc2\xb0",
     "\xc2\xb1",
     "\xc7\xa8",
     "\xc7\xa9",
     "\xc2\xb4",
     "\xc2\xb5",
     "\xc2\xb6",
     "\xc2\xb7",
     "\xc5\x8a",
     "\xc5\x8b",
     "\xc5\xa6",
     "\xc2\xbb",
     "\xc5\xa7",
     "\xc2\xbd",
     "\xc5\xbd",
     "\xc5\xbe",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xc3\x84",
     "\xc3\x85",
     "\xc3\x86",
     "\xc3\x87",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xc3\x8b",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc3\x8e",
     "\xc3\x8f",
     "\xc3\x90",
     "\xc3\x91",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xc3\x95",
     "\xc3\x96",
     "\xc3\x97",
     "\xc3\x98",
     "\xc3\x99",
     "\xc3\x9a",
     "\xc3\x9b",
     "\xc3\x9c",
     "\xc3\x9d",
     "\xc3\x9e",
     "\xc3\x9f",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xc3\xa4",
     "\xc3\xa5",
     "\xc3\xa6",
     "\xc3\xa7",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xc3\xab",
     "\xc3\xac",
     "\xc3\xad",
     "\xc3\xae",
     "\xc3\xaf",
     "\xc3\xb0",
     "\xc3\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xc3\xb6",
     "\xc3\xb7",
     "\xc3\xb8",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc3\xbb",
     "\xc3\xbc",
     "\xc3\xbd",
     "\xc3\xbe",
     "\xc3\xbf",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000a0 => "\xa0",
     0x000000a3 => "\xa3",
     0x000000a4 => "\xa4",
     0x000000a6 => "\xa6",
     0x000000a7 => "\xa7",
     0x000000a8 => "\xa8",
     0x000000a9 => "\xa9",
     0x000000ab => "\xab",
     0x000000ac => "\xac",
     0x000000ad => "\xad",
     0x000000ae => "\xae",
     0x000000b0 => "\xb0",
     0x000000b1 => "\xb1",
     0x000000b4 => "\xb4",
     0x000000b5 => "\xb5",
     0x000000b6 => "\xb6",
     0x000000b7 => "\xb7",
     0x000000bb => "\xbb",
     0x000000bd => "\xbd",
     0x000000c0 => "\xc0",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c3 => "\xc3",
     0x000000c4 => "\xc4",
     0x000000c5 => "\xc5",
     0x000000c6 => "\xc6",
     0x000000c7 => "\xc7",
     0x000000c8 => "\xc8",
     0x000000c9 => "\xc9",
     0x000000ca => "\xca",
     0x000000cb => "\xcb",
     0x000000cc => "\xcc",
     0x000000cd => "\xcd",
     0x000000ce => "\xce",
     0x000000cf => "\xcf",
     0x000000d0 => "\xd0",
     0x000000d1 => "\xd1",
     0x000000d2 => "\xd2",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d5 => "\xd5",
     0x000000d6 => "\xd6",
     0x000000d7 => "\xd7",
     0x000000d8 => "\xd8",
     0x000000d9 => "\xd9",
     0x000000da => "\xda",
     0x000000db => "\xdb",
     0x000000dc => "\xdc",
     0x000000dd => "\xdd",
     0x000000de => "\xde",
     0x000000df => "\xdf",
     0x000000e0 => "\xe0",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e3 => "\xe3",
     0x000000e4 => "\xe4",
     0x000000e5 => "\xe5",
     0x000000e6 => "\xe6",
     0x000000e7 => "\xe7",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000eb => "\xeb",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000ee => "\xee",
     0x000000ef => "\xef",
     0x000000f0 => "\xf0",
     0x000000f1 => "\xf1",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f6 => "\xf6",
     0x000000f7 => "\xf7",
     0x000000f8 => "\xf8",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fb => "\xfb",
     0x000000fc => "\xfc",
     0x000000fd => "\xfd",
     0x000000fe => "\xfe",
     0x000000ff => "\xff",
     0x0000010c => "\x82",
     0x0000010d => "\x84",
     0x00000110 => "\x89",
     0x00000111 => "\x98",
     0x0000014a => "\xb8",
     0x0000014b => "\xb9",
     0x00000152 => "\x8c",
     0x00000153 => "\x9c",
     0x00000160 => "\x8a",
     0x00000161 => "\x9a",
     0x00000166 => "\xba",
     0x00000167 => "\xbc",
     0x00000178 => "\x9f",
     0x0000017d => "\xbe",
     0x0000017e => "\xbf",
     0x00000192 => "\x83",
     0x000001b7 => "\x85",
     0x000001e4 => "\xa2",
     0x000001e5 => "\xa5",
     0x000001e6 => "\x99",
     0x000001e7 => "\xa1",
     0x000001e8 => "\xb2",
     0x000001e9 => "\xb3",
     0x000001ee => "\x87",
     0x000001ef => "\x88",
     0x0000021e => "\xaa",
     0x0000021f => "\xaf",
     0x00000292 => "\x86",
     0x00002013 => "\x96",
     0x00002014 => "\x97",
     0x00002018 => "\x91",
     0x00002019 => "\x92",
     0x0000201c => "\x93",
     0x0000201d => "\x94",
     0x00002022 => "\x95",
     0x00002039 => "\x8b",
     0x0000203a => "\x9b",
     0x000020ac => "\x80",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/TIS_620.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::TIS_620;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x0002,
     0x0003,
     0x0004,
     0x0005,
     0x0006,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x0014,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x0019,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x001e,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0e01,
     0x0e02,
     0x0e03,
     0x0e04,
     0x0e05,
     0x0e06,
     0x0e07,
     0x0e08,
     0x0e09,
     0x0e0a,
     0x0e0b,
     0x0e0c,
     0x0e0d,
     0x0e0e,
     0x0e0f,
     0x0e10,
     0x0e11,
     0x0e12,
     0x0e13,
     0x0e14,
     0x0e15,
     0x0e16,
     0x0e17,
     0x0e18,
     0x0e19,
     0x0e1a,
     0x0e1b,
     0x0e1c,
     0x0e1d,
     0x0e1e,
     0x0e1f,
     0x0e20,
     0x0e21,
     0x0e22,
     0x0e23,
     0x0e24,
     0x0e25,
     0x0e26,
     0x0e27,
     0x0e28,
     0x0e29,
     0x0e2a,
     0x0e2b,
     0x0e2c,
     0x0e2d,
     0x0e2e,
     0x0e2f,
     0x0e30,
     0x0e31,
     0x0e32,
     0x0e33,
     0x0e34,
     0x0e35,
     0x0e36,
     0x0e37,
     0x0e38,
     0x0e39,
     0x0e3a,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
     0x0e3f,
     0x0e40,
     0x0e41,
     0x0e42,
     0x0e43,
     0x0e44,
     0x0e45,
     0x0e46,
     0x0e47,
     0x0e48,
     0x0e49,
     0x0e4a,
     0x0e4b,
     0x0e4c,
     0x0e4d,
     0x0e4e,
     0x0e4f,
     0x0e50,
     0x0e51,
     0x0e52,
     0x0e53,
     0x0e54,
     0x0e55,
     0x0e56,
     0x0e57,
     0x0e58,
     0x0e59,
     0x0e5a,
     0x0e5b,
     0xfffd,
     0xfffd,
     0xfffd,
     0xfffd,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\x02",
     "\x03",
     "\x04",
     "\x05",
     "\x06",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\x14",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\x19",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\x1e",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe0\xb8\x81",
     "\xe0\xb8\x82",
     "\xe0\xb8\x83",
     "\xe0\xb8\x84",
     "\xe0\xb8\x85",
     "\xe0\xb8\x86",
     "\xe0\xb8\x87",
     "\xe0\xb8\x88",
     "\xe0\xb8\x89",
     "\xe0\xb8\x8a",
     "\xe0\xb8\x8b",
     "\xe0\xb8\x8c",
     "\xe0\xb8\x8d",
     "\xe0\xb8\x8e",
     "\xe0\xb8\x8f",
     "\xe0\xb8\x90",
     "\xe0\xb8\x91",
     "\xe0\xb8\x92",
     "\xe0\xb8\x93",
     "\xe0\xb8\x94",
     "\xe0\xb8\x95",
     "\xe0\xb8\x96",
     "\xe0\xb8\x97",
     "\xe0\xb8\x98",
     "\xe0\xb8\x99",
     "\xe0\xb8\x9a",
     "\xe0\xb8\x9b",
     "\xe0\xb8\x9c",
     "\xe0\xb8\x9d",
     "\xe0\xb8\x9e",
     "\xe0\xb8\x9f",
     "\xe0\xb8\xa0",
     "\xe0\xb8\xa1",
     "\xe0\xb8\xa2",
     "\xe0\xb8\xa3",
     "\xe0\xb8\xa4",
     "\xe0\xb8\xa5",
     "\xe0\xb8\xa6",
     "\xe0\xb8\xa7",
     "\xe0\xb8\xa8",
     "\xe0\xb8\xa9",
     "\xe0\xb8\xaa",
     "\xe0\xb8\xab",
     "\xe0\xb8\xac",
     "\xe0\xb8\xad",
     "\xe0\xb8\xae",
     "\xe0\xb8\xaf",
     "\xe0\xb8\xb0",
     "\xe0\xb8\xb1",
     "\xe0\xb8\xb2",
     "\xe0\xb8\xb3",
     "\xe0\xb8\xb4",
     "\xe0\xb8\xb5",
     "\xe0\xb8\xb6",
     "\xe0\xb8\xb7",
     "\xe0\xb8\xb8",
     "\xe0\xb8\xb9",
     "\xe0\xb8\xba",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xe0\xb8\xbf",
     "\xe0\xb9\x80",
     "\xe0\xb9\x81",
     "\xe0\xb9\x82",
     "\xe0\xb9\x83",
     "\xe0\xb9\x84",
     "\xe0\xb9\x85",
     "\xe0\xb9\x86",
     "\xe0\xb9\x87",
     "\xe0\xb9\x88",
     "\xe0\xb9\x89",
     "\xe0\xb9\x8a",
     "\xe0\xb9\x8b",
     "\xe0\xb9\x8c",
     "\xe0\xb9\x8d",
     "\xe0\xb9\x8e",
     "\xe0\xb9\x8f",
     "\xe0\xb9\x90",
     "\xe0\xb9\x91",
     "\xe0\xb9\x92",
     "\xe0\xb9\x93",
     "\xe0\xb9\x94",
     "\xe0\xb9\x95",
     "\xe0\xb9\x96",
     "\xe0\xb9\x97",
     "\xe0\xb9\x98",
     "\xe0\xb9\x99",
     "\xe0\xb9\x9a",
     "\xe0\xb9\x9b",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
     "\xef\xbf\xbd",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000002 => "\x02",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000005 => "\x05",
     0x00000006 => "\x06",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000014 => "\x14",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x00000019 => "\x19",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001e => "\x1e",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x00000e01 => "\xa1",
     0x00000e02 => "\xa2",
     0x00000e03 => "\xa3",
     0x00000e04 => "\xa4",
     0x00000e05 => "\xa5",
     0x00000e06 => "\xa6",
     0x00000e07 => "\xa7",
     0x00000e08 => "\xa8",
     0x00000e09 => "\xa9",
     0x00000e0a => "\xaa",
     0x00000e0b => "\xab",
     0x00000e0c => "\xac",
     0x00000e0d => "\xad",
     0x00000e0e => "\xae",
     0x00000e0f => "\xaf",
     0x00000e10 => "\xb0",
     0x00000e11 => "\xb1",
     0x00000e12 => "\xb2",
     0x00000e13 => "\xb3",
     0x00000e14 => "\xb4",
     0x00000e15 => "\xb5",
     0x00000e16 => "\xb6",
     0x00000e17 => "\xb7",
     0x00000e18 => "\xb8",
     0x00000e19 => "\xb9",
     0x00000e1a => "\xba",
     0x00000e1b => "\xbb",
     0x00000e1c => "\xbc",
     0x00000e1d => "\xbd",
     0x00000e1e => "\xbe",
     0x00000e1f => "\xbf",
     0x00000e20 => "\xc0",
     0x00000e21 => "\xc1",
     0x00000e22 => "\xc2",
     0x00000e23 => "\xc3",
     0x00000e24 => "\xc4",
     0x00000e25 => "\xc5",
     0x00000e26 => "\xc6",
     0x00000e27 => "\xc7",
     0x00000e28 => "\xc8",
     0x00000e29 => "\xc9",
     0x00000e2a => "\xca",
     0x00000e2b => "\xcb",
     0x00000e2c => "\xcc",
     0x00000e2d => "\xcd",
     0x00000e2e => "\xce",
     0x00000e2f => "\xcf",
     0x00000e30 => "\xd0",
     0x00000e31 => "\xd1",
     0x00000e32 => "\xd2",
     0x00000e33 => "\xd3",
     0x00000e34 => "\xd4",
     0x00000e35 => "\xd5",
     0x00000e36 => "\xd6",
     0x00000e37 => "\xd7",
     0x00000e38 => "\xd8",
     0x00000e39 => "\xd9",
     0x00000e3a => "\xda",
     0x00000e3f => "\xdf",
     0x00000e40 => "\xe0",
     0x00000e41 => "\xe1",
     0x00000e42 => "\xe2",
     0x00000e43 => "\xe3",
     0x00000e44 => "\xe4",
     0x00000e45 => "\xe5",
     0x00000e46 => "\xe6",
     0x00000e47 => "\xe7",
     0x00000e48 => "\xe8",
     0x00000e49 => "\xe9",
     0x00000e4a => "\xea",
     0x00000e4b => "\xeb",
     0x00000e4c => "\xec",
     0x00000e4d => "\xed",
     0x00000e4e => "\xee",
     0x00000e4f => "\xef",
     0x00000e50 => "\xf0",
     0x00000e51 => "\xf1",
     0x00000e52 => "\xf2",
     0x00000e53 => "\xf3",
     0x00000e54 => "\xf4",
     0x00000e55 => "\xf5",
     0x00000e56 => "\xf6",
     0x00000e57 => "\xf7",
     0x00000e58 => "\xf8",
     0x00000e59 => "\xf9",
     0x00000e5a => "\xfa",
     0x00000e5b => "\xfb",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/US_ASCII.pm ###
 #! /bin/false
 
 
 
 
 
 
 package Locale::RecodeData::US_ASCII;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '', 
 		    map $_ > 0x7f ? '?' : chr $_,
 			    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8') {
 		$_[1] = join '', 
 		    map $_ > 0x7f ? "\xef\xbf\xbd" : chr $_, unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map { $_ > 0x7f ? 0xfffd : $_ } unpack 'C*', $_[1] ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/UTF_8.pm ###
 #! /bin/false
 
 
 
 
 
 
 package Locale::RecodeData::UTF_8;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 	return $_[0]->_fromInternal ($_[1]);
     } else {
 	return $_[0]->_toInternal ($_[1]);
     }
 }
 
 sub _fromInternal
 {
     $_[1] = join '', map {
 	if ($_ <= 0x7f) {
 	    chr $_;
 	} elsif ($_ <= 0x7ff) {
 	    pack ("C2", 
 		  (0xc0 | (($_ >> 6) & 0x1f)),
 		  (0x80 | ($_ & 0x3f)));
 	} elsif ($_ <= 0xffff) {
 	    pack ("C3", 
 		  (0xe0 | (($_ >> 12) & 0xf)),
 		  (0x80 | (($_ >> 6) & 0x3f)),
 		  (0x80 | ($_ & 0x3f)));
 	} elsif ($_ <= 0x1fffff) {
 	    pack ("C4", 
 		  (0xf0 | (($_ >> 18) & 0x7)),
 		  (0x80 | (($_ >> 12) & 0x3f)),
 		  (0x80 | (($_ >> 6) & 0x3f)),
 		  (0x80 | ($_ & 0x3f)));
 	} elsif ($_ <= 0x3ffffff) {
 	    pack ("C5", 
 		  (0xf0 | (($_ >> 24) & 0x3)),
 		  (0x80 | (($_ >> 18) & 0x3f)),
 		  (0x80 | (($_ >> 12) & 0x3f)),
 		  (0x80 | (($_ >> 6) & 0x3f)),
 		  (0x80 | ($_ & 0x3f)));
 	} else {
 	    pack ("C6", 
 		  (0xf0 | (($_ >> 30) & 0x3)),
 		  (0x80 | (($_ >> 24) & 0x1)),
 		  (0x80 | (($_ >> 18) & 0x3f)),
 		  (0x80 | (($_ >> 12) & 0x3f)),
 		  (0x80 | (($_ >> 6) & 0x3f)),
 		  (0x80 | ($_ & 0x3f)));
 	}
     } @{$_[1]};
     return 1;
 }
 
 sub _toInternal
 {
     if ($] >= 5.006) {
 	$_[1] = [ unpack "U*", $_[1] ];
 	return 1;
     }
 
 
     my @chars = ();
     my @bytes = unpack "C*", $_[1];
 
     BYTE: while (@bytes) {
 	my $byte = shift @bytes;
         if ($byte < 0x80) {
             push @chars, $byte;
         } elsif ($byte < 0xc0 || $byte > 0xfd) {
             push @chars, 0xfffd;
         } else {
             my $num_bytes;
             my $char;
             if ($byte < 0xe0) {
                 $char = $byte & 0x1f;
                 $num_bytes = 1;
             } elsif ($byte < 0xf0) {
                 $char = $byte & 0xf;
                 $num_bytes = 2;
             } elsif ($byte < 0xf8) {
                 $char = $byte & 0x7;
                 $num_bytes = 3;
             } elsif ($byte < 0xfc) {
                 $char = $byte & 0x3;
                 $num_bytes = 4;
             } else {
                 $char = $byte & 0x1;
                 $num_bytes = 5;
             }
             for (my $i = 0; $i < $num_bytes; ++$i) {
                 my $next = shift @bytes;
                 if (!defined $next || $next < 0x80 || $next > 0xbf) {
                     push @chars, 0xfffd;
                     next BYTE;
                 } else {
                     $char <<= 6;
                     $char |= $next & 0x3f;
                 }
             }
             push @chars, $char;
         }
     }
     
     $_[1] = \@chars;
     
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/VISCII.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::VISCII;
 
 use strict;
 
 require Locale::RecodeData;
 use base qw(Locale::RecodeData);
 
 my @to_ucs4 = (
     0x0000,
     0x0001,
     0x1eb2,
     0x0003,
     0x0004,
     0x1eb4,
     0x1eaa,
     0x0007,
     0x0008,
     0x0009,
     0x000a,
     0x000b,
     0x000c,
     0x000d,
     0x000e,
     0x000f,
     0x0010,
     0x0011,
     0x0012,
     0x0013,
     0x1ef6,
     0x0015,
     0x0016,
     0x0017,
     0x0018,
     0x1ef8,
     0x001a,
     0x001b,
     0x001c,
     0x001d,
     0x1ef4,
     0x001f,
     0x0020,
     0x0021,
     0x0022,
     0x0023,
     0x0024,
     0x0025,
     0x0026,
     0x0027,
     0x0028,
     0x0029,
     0x002a,
     0x002b,
     0x002c,
     0x002d,
     0x002e,
     0x002f,
     0x0030,
     0x0031,
     0x0032,
     0x0033,
     0x0034,
     0x0035,
     0x0036,
     0x0037,
     0x0038,
     0x0039,
     0x003a,
     0x003b,
     0x003c,
     0x003d,
     0x003e,
     0x003f,
     0x0040,
     0x0041,
     0x0042,
     0x0043,
     0x0044,
     0x0045,
     0x0046,
     0x0047,
     0x0048,
     0x0049,
     0x004a,
     0x004b,
     0x004c,
     0x004d,
     0x004e,
     0x004f,
     0x0050,
     0x0051,
     0x0052,
     0x0053,
     0x0054,
     0x0055,
     0x0056,
     0x0057,
     0x0058,
     0x0059,
     0x005a,
     0x005b,
     0x005c,
     0x005d,
     0x005e,
     0x005f,
     0x0060,
     0x0061,
     0x0062,
     0x0063,
     0x0064,
     0x0065,
     0x0066,
     0x0067,
     0x0068,
     0x0069,
     0x006a,
     0x006b,
     0x006c,
     0x006d,
     0x006e,
     0x006f,
     0x0070,
     0x0071,
     0x0072,
     0x0073,
     0x0074,
     0x0075,
     0x0076,
     0x0077,
     0x0078,
     0x0079,
     0x007a,
     0x007b,
     0x007c,
     0x007d,
     0x007e,
     0x007f,
     0x1ea0,
     0x1eae,
     0x1eb0,
     0x1eb6,
     0x1ea4,
     0x1ea6,
     0x1ea8,
     0x1eac,
     0x1ebc,
     0x1eb8,
     0x1ebe,
     0x1ec0,
     0x1ec2,
     0x1ec4,
     0x1ec6,
     0x1ed0,
     0x1ed2,
     0x1ed4,
     0x1ed6,
     0x1ed8,
     0x1ee2,
     0x1eda,
     0x1edc,
     0x1ede,
     0x1eca,
     0x1ece,
     0x1ecc,
     0x1ec8,
     0x1ee6,
     0x0168,
     0x1ee4,
     0x1ef2,
     0x00d5,
     0x1eaf,
     0x1eb1,
     0x1eb7,
     0x1ea5,
     0x1ea7,
     0x1ea9,
     0x1ead,
     0x1ebd,
     0x1eb9,
     0x1ebf,
     0x1ec1,
     0x1ec3,
     0x1ec5,
     0x1ec7,
     0x1ed1,
     0x1ed3,
     0x1ed5,
     0x1ed7,
     0x1ee0,
     0x01a0,
     0x1ed9,
     0x1edd,
     0x1edf,
     0x1ecb,
     0x1ef0,
     0x1ee8,
     0x1eea,
     0x1eec,
     0x01a1,
     0x1edb,
     0x01af,
     0x00c0,
     0x00c1,
     0x00c2,
     0x00c3,
     0x1ea2,
     0x0102,
     0x1eb3,
     0x1eb5,
     0x00c8,
     0x00c9,
     0x00ca,
     0x1eba,
     0x00cc,
     0x00cd,
     0x0128,
     0x1ef3,
     0x0110,
     0x1ee9,
     0x00d2,
     0x00d3,
     0x00d4,
     0x1ea1,
     0x1ef7,
     0x1eeb,
     0x1eed,
     0x00d9,
     0x00da,
     0x1ef9,
     0x1ef5,
     0x00dd,
     0x1ee1,
     0x01b0,
     0x00e0,
     0x00e1,
     0x00e2,
     0x00e3,
     0x1ea3,
     0x0103,
     0x1eef,
     0x1eab,
     0x00e8,
     0x00e9,
     0x00ea,
     0x1ebb,
     0x00ec,
     0x00ed,
     0x0129,
     0x1ec9,
     0x0111,
     0x1ef1,
     0x00f2,
     0x00f3,
     0x00f4,
     0x00f5,
     0x1ecf,
     0x1ecd,
     0x1ee5,
     0x00f9,
     0x00fa,
     0x0169,
     0x1ee7,
     0x00fd,
     0x1ee3,
     0x1eee,
 );
 
 my @to_utf8 = (
     "\x00",
     "\x01",
     "\xe1\xba\xb2",
     "\x03",
     "\x04",
     "\xe1\xba\xb4",
     "\xe1\xba\xaa",
     "\x07",
     "\x08",
     "\x09",
     "\x0a",
     "\x0b",
     "\x0c",
     "\x0d",
     "\x0e",
     "\x0f",
     "\x10",
     "\x11",
     "\x12",
     "\x13",
     "\xe1\xbb\xb6",
     "\x15",
     "\x16",
     "\x17",
     "\x18",
     "\xe1\xbb\xb8",
     "\x1a",
     "\x1b",
     "\x1c",
     "\x1d",
     "\xe1\xbb\xb4",
     "\x1f",
     "\x20",
     "\x21",
     "\x22",
     "\x23",
     "\x24",
     "\x25",
     "\x26",
     "\x27",
     "\x28",
     "\x29",
     "\x2a",
     "\x2b",
     "\x2c",
     "\x2d",
     "\x2e",
     "\x2f",
     "\x30",
     "\x31",
     "\x32",
     "\x33",
     "\x34",
     "\x35",
     "\x36",
     "\x37",
     "\x38",
     "\x39",
     "\x3a",
     "\x3b",
     "\x3c",
     "\x3d",
     "\x3e",
     "\x3f",
     "\x40",
     "\x41",
     "\x42",
     "\x43",
     "\x44",
     "\x45",
     "\x46",
     "\x47",
     "\x48",
     "\x49",
     "\x4a",
     "\x4b",
     "\x4c",
     "\x4d",
     "\x4e",
     "\x4f",
     "\x50",
     "\x51",
     "\x52",
     "\x53",
     "\x54",
     "\x55",
     "\x56",
     "\x57",
     "\x58",
     "\x59",
     "\x5a",
     "\x5b",
     "\x5c",
     "\x5d",
     "\x5e",
     "\x5f",
     "\x60",
     "\x61",
     "\x62",
     "\x63",
     "\x64",
     "\x65",
     "\x66",
     "\x67",
     "\x68",
     "\x69",
     "\x6a",
     "\x6b",
     "\x6c",
     "\x6d",
     "\x6e",
     "\x6f",
     "\x70",
     "\x71",
     "\x72",
     "\x73",
     "\x74",
     "\x75",
     "\x76",
     "\x77",
     "\x78",
     "\x79",
     "\x7a",
     "\x7b",
     "\x7c",
     "\x7d",
     "\x7e",
     "\x7f",
     "\xe1\xba\xa0",
     "\xe1\xba\xae",
     "\xe1\xba\xb0",
     "\xe1\xba\xb6",
     "\xe1\xba\xa4",
     "\xe1\xba\xa6",
     "\xe1\xba\xa8",
     "\xe1\xba\xac",
     "\xe1\xba\xbc",
     "\xe1\xba\xb8",
     "\xe1\xba\xbe",
     "\xe1\xbb\x80",
     "\xe1\xbb\x82",
     "\xe1\xbb\x84",
     "\xe1\xbb\x86",
     "\xe1\xbb\x90",
     "\xe1\xbb\x92",
     "\xe1\xbb\x94",
     "\xe1\xbb\x96",
     "\xe1\xbb\x98",
     "\xe1\xbb\xa2",
     "\xe1\xbb\x9a",
     "\xe1\xbb\x9c",
     "\xe1\xbb\x9e",
     "\xe1\xbb\x8a",
     "\xe1\xbb\x8e",
     "\xe1\xbb\x8c",
     "\xe1\xbb\x88",
     "\xe1\xbb\xa6",
     "\xc5\xa8",
     "\xe1\xbb\xa4",
     "\xe1\xbb\xb2",
     "\xc3\x95",
     "\xe1\xba\xaf",
     "\xe1\xba\xb1",
     "\xe1\xba\xb7",
     "\xe1\xba\xa5",
     "\xe1\xba\xa7",
     "\xe1\xba\xa9",
     "\xe1\xba\xad",
     "\xe1\xba\xbd",
     "\xe1\xba\xb9",
     "\xe1\xba\xbf",
     "\xe1\xbb\x81",
     "\xe1\xbb\x83",
     "\xe1\xbb\x85",
     "\xe1\xbb\x87",
     "\xe1\xbb\x91",
     "\xe1\xbb\x93",
     "\xe1\xbb\x95",
     "\xe1\xbb\x97",
     "\xe1\xbb\xa0",
     "\xc6\xa0",
     "\xe1\xbb\x99",
     "\xe1\xbb\x9d",
     "\xe1\xbb\x9f",
     "\xe1\xbb\x8b",
     "\xe1\xbb\xb0",
     "\xe1\xbb\xa8",
     "\xe1\xbb\xaa",
     "\xe1\xbb\xac",
     "\xc6\xa1",
     "\xe1\xbb\x9b",
     "\xc6\xaf",
     "\xc3\x80",
     "\xc3\x81",
     "\xc3\x82",
     "\xc3\x83",
     "\xe1\xba\xa2",
     "\xc4\x82",
     "\xe1\xba\xb3",
     "\xe1\xba\xb5",
     "\xc3\x88",
     "\xc3\x89",
     "\xc3\x8a",
     "\xe1\xba\xba",
     "\xc3\x8c",
     "\xc3\x8d",
     "\xc4\xa8",
     "\xe1\xbb\xb3",
     "\xc4\x90",
     "\xe1\xbb\xa9",
     "\xc3\x92",
     "\xc3\x93",
     "\xc3\x94",
     "\xe1\xba\xa1",
     "\xe1\xbb\xb7",
     "\xe1\xbb\xab",
     "\xe1\xbb\xad",
     "\xc3\x99",
     "\xc3\x9a",
     "\xe1\xbb\xb9",
     "\xe1\xbb\xb5",
     "\xc3\x9d",
     "\xe1\xbb\xa1",
     "\xc6\xb0",
     "\xc3\xa0",
     "\xc3\xa1",
     "\xc3\xa2",
     "\xc3\xa3",
     "\xe1\xba\xa3",
     "\xc4\x83",
     "\xe1\xbb\xaf",
     "\xe1\xba\xab",
     "\xc3\xa8",
     "\xc3\xa9",
     "\xc3\xaa",
     "\xe1\xba\xbb",
     "\xc3\xac",
     "\xc3\xad",
     "\xc4\xa9",
     "\xe1\xbb\x89",
     "\xc4\x91",
     "\xe1\xbb\xb1",
     "\xc3\xb2",
     "\xc3\xb3",
     "\xc3\xb4",
     "\xc3\xb5",
     "\xe1\xbb\x8f",
     "\xe1\xbb\x8d",
     "\xe1\xbb\xa5",
     "\xc3\xb9",
     "\xc3\xba",
     "\xc5\xa9",
     "\xe1\xbb\xa7",
     "\xc3\xbd",
     "\xe1\xbb\xa3",
     "\xe1\xbb\xae",
 );
 
 my %from_ucs4 = (
     0x00000000 => "\x00",
     0x00000001 => "\x01",
     0x00000003 => "\x03",
     0x00000004 => "\x04",
     0x00000007 => "\x07",
     0x00000008 => "\x08",
     0x00000009 => "\x09",
     0x0000000a => "\x0a",
     0x0000000b => "\x0b",
     0x0000000c => "\x0c",
     0x0000000d => "\x0d",
     0x0000000e => "\x0e",
     0x0000000f => "\x0f",
     0x00000010 => "\x10",
     0x00000011 => "\x11",
     0x00000012 => "\x12",
     0x00000013 => "\x13",
     0x00000015 => "\x15",
     0x00000016 => "\x16",
     0x00000017 => "\x17",
     0x00000018 => "\x18",
     0x0000001a => "\x1a",
     0x0000001b => "\x1b",
     0x0000001c => "\x1c",
     0x0000001d => "\x1d",
     0x0000001f => "\x1f",
     0x00000020 => "\x20",
     0x00000021 => "\x21",
     0x00000022 => "\x22",
     0x00000023 => "\x23",
     0x00000024 => "\x24",
     0x00000025 => "\x25",
     0x00000026 => "\x26",
     0x00000027 => "\x27",
     0x00000028 => "\x28",
     0x00000029 => "\x29",
     0x0000002a => "\x2a",
     0x0000002b => "\x2b",
     0x0000002c => "\x2c",
     0x0000002d => "\x2d",
     0x0000002e => "\x2e",
     0x0000002f => "\x2f",
     0x00000030 => "\x30",
     0x00000031 => "\x31",
     0x00000032 => "\x32",
     0x00000033 => "\x33",
     0x00000034 => "\x34",
     0x00000035 => "\x35",
     0x00000036 => "\x36",
     0x00000037 => "\x37",
     0x00000038 => "\x38",
     0x00000039 => "\x39",
     0x0000003a => "\x3a",
     0x0000003b => "\x3b",
     0x0000003c => "\x3c",
     0x0000003d => "\x3d",
     0x0000003e => "\x3e",
     0x0000003f => "\x3f",
     0x00000040 => "\x40",
     0x00000041 => "\x41",
     0x00000042 => "\x42",
     0x00000043 => "\x43",
     0x00000044 => "\x44",
     0x00000045 => "\x45",
     0x00000046 => "\x46",
     0x00000047 => "\x47",
     0x00000048 => "\x48",
     0x00000049 => "\x49",
     0x0000004a => "\x4a",
     0x0000004b => "\x4b",
     0x0000004c => "\x4c",
     0x0000004d => "\x4d",
     0x0000004e => "\x4e",
     0x0000004f => "\x4f",
     0x00000050 => "\x50",
     0x00000051 => "\x51",
     0x00000052 => "\x52",
     0x00000053 => "\x53",
     0x00000054 => "\x54",
     0x00000055 => "\x55",
     0x00000056 => "\x56",
     0x00000057 => "\x57",
     0x00000058 => "\x58",
     0x00000059 => "\x59",
     0x0000005a => "\x5a",
     0x0000005b => "\x5b",
     0x0000005c => "\x5c",
     0x0000005d => "\x5d",
     0x0000005e => "\x5e",
     0x0000005f => "\x5f",
     0x00000060 => "\x60",
     0x00000061 => "\x61",
     0x00000062 => "\x62",
     0x00000063 => "\x63",
     0x00000064 => "\x64",
     0x00000065 => "\x65",
     0x00000066 => "\x66",
     0x00000067 => "\x67",
     0x00000068 => "\x68",
     0x00000069 => "\x69",
     0x0000006a => "\x6a",
     0x0000006b => "\x6b",
     0x0000006c => "\x6c",
     0x0000006d => "\x6d",
     0x0000006e => "\x6e",
     0x0000006f => "\x6f",
     0x00000070 => "\x70",
     0x00000071 => "\x71",
     0x00000072 => "\x72",
     0x00000073 => "\x73",
     0x00000074 => "\x74",
     0x00000075 => "\x75",
     0x00000076 => "\x76",
     0x00000077 => "\x77",
     0x00000078 => "\x78",
     0x00000079 => "\x79",
     0x0000007a => "\x7a",
     0x0000007b => "\x7b",
     0x0000007c => "\x7c",
     0x0000007d => "\x7d",
     0x0000007e => "\x7e",
     0x0000007f => "\x7f",
     0x000000c0 => "\xc0",
     0x000000c1 => "\xc1",
     0x000000c2 => "\xc2",
     0x000000c3 => "\xc3",
     0x000000c8 => "\xc8",
     0x000000c9 => "\xc9",
     0x000000ca => "\xca",
     0x000000cc => "\xcc",
     0x000000cd => "\xcd",
     0x000000d2 => "\xd2",
     0x000000d3 => "\xd3",
     0x000000d4 => "\xd4",
     0x000000d5 => "\xa0",
     0x000000d9 => "\xd9",
     0x000000da => "\xda",
     0x000000dd => "\xdd",
     0x000000e0 => "\xe0",
     0x000000e1 => "\xe1",
     0x000000e2 => "\xe2",
     0x000000e3 => "\xe3",
     0x000000e8 => "\xe8",
     0x000000e9 => "\xe9",
     0x000000ea => "\xea",
     0x000000ec => "\xec",
     0x000000ed => "\xed",
     0x000000f2 => "\xf2",
     0x000000f3 => "\xf3",
     0x000000f4 => "\xf4",
     0x000000f5 => "\xf5",
     0x000000f9 => "\xf9",
     0x000000fa => "\xfa",
     0x000000fd => "\xfd",
     0x00000102 => "\xc5",
     0x00000103 => "\xe5",
     0x00000110 => "\xd0",
     0x00000111 => "\xf0",
     0x00000128 => "\xce",
     0x00000129 => "\xee",
     0x00000168 => "\x9d",
     0x00000169 => "\xfb",
     0x000001a0 => "\xb4",
     0x000001a1 => "\xbd",
     0x000001af => "\xbf",
     0x000001b0 => "\xdf",
     0x00001ea0 => "\x80",
     0x00001ea1 => "\xd5",
     0x00001ea2 => "\xc4",
     0x00001ea3 => "\xe4",
     0x00001ea4 => "\x84",
     0x00001ea5 => "\xa4",
     0x00001ea6 => "\x85",
     0x00001ea7 => "\xa5",
     0x00001ea8 => "\x86",
     0x00001ea9 => "\xa6",
     0x00001eaa => "\x06",
     0x00001eab => "\xe7",
     0x00001eac => "\x87",
     0x00001ead => "\xa7",
     0x00001eae => "\x81",
     0x00001eaf => "\xa1",
     0x00001eb0 => "\x82",
     0x00001eb1 => "\xa2",
     0x00001eb2 => "\x02",
     0x00001eb3 => "\xc6",
     0x00001eb4 => "\x05",
     0x00001eb5 => "\xc7",
     0x00001eb6 => "\x83",
     0x00001eb7 => "\xa3",
     0x00001eb8 => "\x89",
     0x00001eb9 => "\xa9",
     0x00001eba => "\xcb",
     0x00001ebb => "\xeb",
     0x00001ebc => "\x88",
     0x00001ebd => "\xa8",
     0x00001ebe => "\x8a",
     0x00001ebf => "\xaa",
     0x00001ec0 => "\x8b",
     0x00001ec1 => "\xab",
     0x00001ec2 => "\x8c",
     0x00001ec3 => "\xac",
     0x00001ec4 => "\x8d",
     0x00001ec5 => "\xad",
     0x00001ec6 => "\x8e",
     0x00001ec7 => "\xae",
     0x00001ec8 => "\x9b",
     0x00001ec9 => "\xef",
     0x00001eca => "\x98",
     0x00001ecb => "\xb8",
     0x00001ecc => "\x9a",
     0x00001ecd => "\xf7",
     0x00001ece => "\x99",
     0x00001ecf => "\xf6",
     0x00001ed0 => "\x8f",
     0x00001ed1 => "\xaf",
     0x00001ed2 => "\x90",
     0x00001ed3 => "\xb0",
     0x00001ed4 => "\x91",
     0x00001ed5 => "\xb1",
     0x00001ed6 => "\x92",
     0x00001ed7 => "\xb2",
     0x00001ed8 => "\x93",
     0x00001ed9 => "\xb5",
     0x00001eda => "\x95",
     0x00001edb => "\xbe",
     0x00001edc => "\x96",
     0x00001edd => "\xb6",
     0x00001ede => "\x97",
     0x00001edf => "\xb7",
     0x00001ee0 => "\xb3",
     0x00001ee1 => "\xde",
     0x00001ee2 => "\x94",
     0x00001ee3 => "\xfe",
     0x00001ee4 => "\x9e",
     0x00001ee5 => "\xf8",
     0x00001ee6 => "\x9c",
     0x00001ee7 => "\xfc",
     0x00001ee8 => "\xba",
     0x00001ee9 => "\xd1",
     0x00001eea => "\xbb",
     0x00001eeb => "\xd7",
     0x00001eec => "\xbc",
     0x00001eed => "\xd8",
     0x00001eee => "\xff",
     0x00001eef => "\xe6",
     0x00001ef0 => "\xb9",
     0x00001ef1 => "\xf1",
     0x00001ef2 => "\x9f",
     0x00001ef3 => "\xcf",
     0x00001ef4 => "\x1e",
     0x00001ef5 => "\xdc",
     0x00001ef6 => "\x14",
     0x00001ef7 => "\xd6",
     0x00001ef8 => "\x19",
     0x00001ef9 => "\xdb",
 );
 
 sub _recode
 {
     if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = join '',
 	        map $from_ucs4{$_} 
                 || (defined $from_ucs4{$_} ? $from_ucs4{$_} : "\x3f"),
 		    @{$_[1]};
     } elsif ($_[0]->{_to} eq 'UTF-8',) {
 		$_[1] = join '', map $to_utf8[$_], unpack 'C*', $_[1];
     } else {
 		$_[1] = [ map 
 				  $to_ucs4[$_],
 				  unpack 'C*', $_[1] 
 				  ];
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/RecodeData/_Encode.pm ###
 #! /bin/false
 
 
 
 
 
 package Locale::RecodeData::_Encode;
 
 use strict;
 use integer;
 
 use Encode;
 
 require Locale::RecodeData;
 use base qw (Locale::RecodeData);
 
 sub _recode
 {
 	use bytes;
 
 	my $retval;
 	
 	if ($_[0]->{_from} eq 'INTERNAL') {
 		$_[1] = pack "N*", @{$_[1]};
 		$retval = Encode::from_to ($_[1], 'UTF-32BE', $_[0]->{_to});
 	} elsif ($_[0]->{_to} eq 'INTERNAL') {
 		$retval = Encode::from_to ($_[1], $_[0]->{_from}, 'UTF-32BE');
 		return unless defined $retval;
 		$_[1] = [ unpack "N*", $_[1] ];
 	} else {
 		$retval = Encode::from_to ($_[1], $_[0]->{_from}, $_[0]->{_to});
 	}
 	
 	return unless defined $retval;
 	return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/TextDomain.pm ###
 #! /bin/false
 
 
 
 
 
 
 package __TiedTextDomain;
 
 use strict;
 
 sub TIEHASH
 {
     my ($class, $function) = @_;
     bless {
         __function => $function,
     }, $class;
 }
 
 sub FETCH
 {
     my ($self, $msg) = @_;
     
     &{$self->{__function}} ($msg);
 }
 
 sub FIRSTKEY
 {
     my $self = shift;
     my $reset_iterator = keys %$self;
     return scalar each %$self;
 }
 
 sub NEXTKEY
 {
     my $self = shift;
     return scalar each %$self;
 }
 
 sub CLEAR {}
 sub STORE {}
 sub DELETE {}
 
 1;
 
 package Locale::TextDomain;
 
 use strict;
 
 use Locale::Messages qw (textdomain bindtextdomain dgettext dngettext dpgettext dnpgettext);
 use Cwd qw (abs_path);
 
 use vars qw ($VERSION);
 
 $VERSION = '1.24';
 
 require Exporter;
 
 use vars qw (@ISA @EXPORT %__ $__);
 
 @ISA = ('Exporter');
 @EXPORT = qw (__ __x __n __nx __xn __p __px __np __npx $__ %__ 
               N__ N__n N__p N__np);
 
 my %textdomains = ();
 my %bound_dirs = ();
 my @default_dirs = ();
 
 sub __ ($);
 	
 sub __find_domain ($);
 sub __expand ($%);
 sub __tied_gettext ($$);
 
 BEGIN {
     tie %__, '__TiedTextDomain', \&__tied_gettext;
     $__ = \%__;
 
 	for my $dir (qw (/usr/share/locale /usr/local/share/locale)) {
         if (-d $dir) {
             @default_dirs = ($dir);
             last;
         }
     }
 }
 
 sub __ ($)
 {
     my $msgid = shift;
 	
     my $package = caller;
     
     my $textdomain = $textdomains{$package};
     
     __find_domain $textdomain if 
 		defined $textdomain && defined $bound_dirs{$textdomain};
     
     return dgettext $textdomain => $msgid;
 }
 
 sub __tied_gettext ($$)
 {
     my ($msgid) = @_;
     
     my ($package) = caller (1);
     
     my $textdomain = $textdomains{$package};
     unless (defined $textdomain) {
 		my ($maybe_package, $filename, $line) = caller (2);
 		if (exists $textdomains{$maybe_package}) {
 			warn <<EOF;
 Probable use of \$__ or \%__ where __() should be used at $filename:$line.
 EOF
 		}
 	}
     __find_domain $textdomain if
 		defined $textdomain && defined $bound_dirs{$textdomain};
     
     return dgettext $textdomain => $msgid;
 }
 
 sub __x ($@)
 {
     my ($msgid, %vars) = @_;
     
     my $package = caller;
     
     my $textdomain = $textdomains{$package};
     
     __find_domain $textdomain if
 		defined $textdomain && defined $bound_dirs{$textdomain};
     
     return __expand ((dgettext $textdomain => $msgid), %vars);
 }
 
 sub __n ($$$)
 {
     my ($msgid, $msgid_plural, $count) = @_;
     
     my $package = caller;
     
     my $textdomain = $textdomains{$package};
     
     __find_domain $textdomain if
 		defined $textdomain && defined $bound_dirs{$textdomain};
     
     return dngettext $textdomain, $msgid, $msgid_plural, $count;
 }
 
 sub __nx ($$$@)
 {
     my ($msgid, $msgid_plural, $count, %args) = @_;
     
     my $package = caller;
     
     my $textdomain = $textdomains{$package};
     
     __find_domain $textdomain if
 		defined $textdomain && defined $bound_dirs{$textdomain};
     
     return __expand ((dngettext $textdomain, $msgid, $msgid_plural, $count),
 					 %args);
 }
 
 sub __xn ($$$@)
 {
     my ($msgid, $msgid_plural, $count, %args) = @_;
     
     my $package = caller;
     
     my $textdomain = $textdomains{$package};
     
     __find_domain $textdomain if
 		defined $textdomain && defined $bound_dirs{$textdomain};
     
     return __expand ((dngettext $textdomain, $msgid, $msgid_plural, $count),
 					 %args);
 }
 
 sub __p ($$)
 {
     my $msgctxt = shift;
     my $msgid = shift;
 	
     my $package = caller;
     
     my $textdomain = $textdomains{$package};
     
     __find_domain $textdomain if 
 		defined $textdomain && defined $bound_dirs{$textdomain};
     
     return dpgettext $textdomain => $msgctxt, $msgid;
 }
 
 sub __px ($$@)
 {
     my ($msgctxt, $msgid, %vars) = @_;
     
     my $package = caller;
     
     my $textdomain = $textdomains{$package};
     
     __find_domain $textdomain if
 		defined $textdomain && defined $bound_dirs{$textdomain};
     
     return __expand ((dpgettext $textdomain => $msgctxt, $msgid), %vars);
 }
 
 sub __np ($$$$)
 {
     my ($msgctxt, $msgid, $msgid_plural, $count) = @_;
     
     my $package = caller;
     
     my $textdomain = $textdomains{$package};
     
     __find_domain $textdomain if
 		defined $textdomain && defined $bound_dirs{$textdomain};
     
     return dnpgettext $textdomain, $msgctxt, $msgid, $msgid_plural, $count;
 }
 
 sub __npx ($$$$@)
 {
     my ($msgctxt, $msgid, $msgid_plural, $count, %args) = @_;
     
     my $package = caller;
     
     my $textdomain = $textdomains{$package};
     
     __find_domain $textdomain if
 		defined $textdomain && defined $bound_dirs{$textdomain};
     
     return __expand ((dnpgettext $textdomain, $msgctxt, $msgid, $msgid_plural, $count),
 					 %args);
 }
 
 sub N__($)
 {
     return shift;
 }
 
 sub N__n($$$)
 {
     return @_;
 }
 
 sub N__p($$) {
     return @_;
 }
 
 sub N__np($$$$) {
     return @_;
 }
 
 sub import
 {
     my ($self, $textdomain, @search_dirs) = @_;
     
     my $package = caller;
     return if exists $textdomains{$package};
     
 	$textdomain = textdomain unless defined $textdomain && length $textdomain;
     
     $textdomains{$package} = $textdomain;
     
     unless (exists $bound_dirs{$textdomain}) {
 		unless (@search_dirs) {
 			@search_dirs = ((map $_ . '/LocaleData', @INC), @default_dirs)
 				unless @search_dirs;
 			if (my $share = eval {
 				require File::ShareDir;
 				File::ShareDir::dist_dir ($textdomain);
 			}) {
 				unshift @search_dirs, 
                         map { "$share/$_" }
                         qw (locale LocaleData);
             }
 		}
 		$bound_dirs{$textdomain} = [grep { -d $_ } @search_dirs];
     }
 	
     Locale::TextDomain->export_to_level (1, $package, @EXPORT);
     
     return;
 }
 
 sub __find_domain ($)
 {
 	my $domain = shift;
 	
 	my $try_dirs = $bound_dirs{$domain};
 	
 	if (defined $try_dirs) {
 		my $found_dir = '';
 		
 		TRYDIR: foreach my $dir (map { abs_path $_ } grep { -d $_ } @$try_dirs) {
 			local *DIR;
 			if (opendir DIR, $dir) {
 				my @files = map { "$dir/$_/LC_MESSAGES/$domain.mo" } 
 					grep { ! /^\.\.?$/ } readdir DIR;
 
 				foreach my $file (@files) {
 					if (-f $file || -l $file) {
 						$found_dir = $dir;
 						last TRYDIR;
 					}
 				}
 			}
 		}
 		
 		bindtextdomain $domain => $found_dir;
     }
     
     undef $bound_dirs{$domain};
     
     return 1;
 }
 
 sub __expand ($%)
 {
     my ($translation, %args) = @_;
     
     my $re = join '|', map { quotemeta $_ } keys %args;
     $translation =~ s/\{($re)\}/defined $args{$1} ? $args{$1} : "{$1}"/ge;
     
     return $translation;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/TextDomain/UTF8.pm ###
 package Locale::TextDomain::UTF8;
 
 use 5.010001;
 use strict;
 use warnings;
 
 our $VERSION = '0.01'; 
 
 use Encode             ();
 use Locale::Messages   ();
 
 $ENV{OUTPUT_CHARSET} = 'UTF-8';
 sub import {
     my ($class, $textdomain, @search_dirs) = @_;
 
     my $pkg = caller;
 
     eval qq[package $pkg; use Locale::TextDomain \$textdomain, \@search_dirs;];
     die $@ if $@;
     Locale::Messages::bind_textdomain_filter(
         $textdomain, \&Encode::decode_utf8);
 }
 
 1;
 
 __END__
 
### Locale/Util.pm ###
 #! /bin/false
 
 
 
 
 
 
 package Locale::Util;
 
 use strict;
 
 use constant DEBUG => 0;
 
 use base qw (Exporter);
 
 use vars qw (@EXPORT_OK);
 
 @EXPORT_OK = qw (parse_http_accept_language
 				 parse_http_accept_charset
 				 set_locale set_locale_cache get_locale_cache
 				 web_set_locale);
 
 use constant LANG2COUNTRY => {
     aa => 'ET', 
     ab => 'AB', 
     af => 'za',  
     am => 'ET', 
     ar => 'EG', 
     as => 'IN', 
     ay => 'BO', 
     az => 'AZ', 
     ba => 'RU', 
     be => 'BY', 
     bg => 'BG', 
     bh => 'IN', 
     bi => 'VU', 
     bn => 'BD', 
     bo => 'CN', 
     br => 'FR', 
     bs => 'BA', 
     ca => 'ES', 
     ce => 'RU', 
     ch => '??', 
     co => 'FR', 
     cs => 'CZ', 
     cu => 'BG', 
     cv => 'RU', 
     cy => 'GB', 
     da => 'DK', 
     de => 'DE', 
     dz => 'BT', 
     el => 'GR', 
     en => 'US', 
     es => 'ES', 
     et => 'EE', 
     fa => 'IR', 
     fi => 'FI', 
     fj => 'FJ', 
     fo => 'FO', 
     fr => 'FR', 
     fy => 'FY', 
     ga => 'IE', 
     gd => 'GB', 
     gl => 'ES', 
     gn => 'PY', 
     gu => 'IN', 
     gv => 'GB', 
     ha => 'NE', 
     he => 'IL', 
     hi => 'IN', 
     ho => 'PG', 
     hr => 'HR', 
     hu => 'HU', 
     hy => 'AM', 
     hz => 'NA', 
     id => 'ID', 
     ik => 'US', 
     is => 'IS', 
     it => 'IT', 
     iu => 'CA', 
     iw => 'IL', 
     ja => 'JP', 
     jw => 'ID', 
     ka => 'GE', 
     ki => 'KE', 
     kj => 'AO', 
     kk => 'KZ', 
     kl => 'GL', 
     km => 'KH', 
     kn => 'IN', 
     ko => 'KR', 
     ks => 'IN', 
     ku => 'TR', 
     kv => 'RU', 
     kw => 'GB', 
     ky => 'KG', 
     la => 'VA', 
     lb => 'LU', 
     ln => 'CG', 
     lo => 'LA', 
     lt => 'LT', 
     lv => 'LV', 
     mg => 'MG', 
     mh => 'MH', 
     mi => 'NZ', 
     mk => 'MK', 
     ml => 'IN', 
     mn => 'MN', 
     mr => 'IN', 
     ms => 'MY', 
     mt => 'MT', 
     my => 'MM', 
     na => 'NR', 
     nb => 'NO', 
     nd => 'ZA', 
     ne => 'NP', 
     ng => 'NA', 
     nl => 'NL', 
     nn => 'NO', 
     no => 'NO', 
     nr => 'ZA', 
     nv => 'US', 
     ny => 'MW', 
     oc => 'FR', 
     om => 'ET', 
     or => 'IN', 
     os => 'RU', 
     pa => 'IN', 
     pi => 'IN', 
     pl => 'PL', 
     ps => 'PK', 
     pt => 'PT', 
     qu => 'PE', 
     rm => 'CH', 
     rn => 'RW', 
     ro => 'RO', 
     ru => 'RU', 
     rw => 'RW', 
     sa => 'IN', 
     sc => 'IT', 
     sd => 'IN', 
     se => 'SE', 
     sg => '??', 
     si => 'LK', 
     sk => 'SK', 
     sl => 'SI', 
     sm => 'WS', 
     sh => 'ZW', 
     so => 'SO', 
     sq => 'AL', 
     sr => 'YU', 
     ss => '??', 
     st => 'LS', 
     su => 'IN', 
     sv => 'SE', 
     sw => 'TZ', 
     ta => 'LK', 
     te => 'IN', 
     tg => 'TJ', 
     th => 'TH', 
     ti => 'ER', 
     tk => 'TM', 
     tl => 'PH', 
     tn => 'BW', 
     to => 'TO', 
     tr => 'TR', 
     tt => 'RU', 
     tw => 'GH', 
     ug => 'CN', 
     uk => 'UA', 
     ur => 'PK', 
     uz => 'UZ', 
     vi => 'VN', 
     wo => 'SN', 
     xh => 'ZA', 
     yi => 'IL', 
     yo => 'NG', 
     za => 'CN', 
     zh => 'CN', 
     zu => 'ZA', 
 };
 
 use constant WIN32LANGUAGE => {
     aa => "Afar",
     ab => "Abkhazian",
     ae => "Avestan",
     af => "Afrikaans",
     am => "Amharic",
     ar => "Arabic",
     as => "Assamese",
     ay => "Aymara",
     az => "Azerbaijani",
     ba => "Bashkir",
     be => "Belarusian",
     bg => "Bulgarian",
     bh => "Bihari",
     bi => "Bislama",
     bn => "Bengali",
     bo => "Tibetan",
     br => "Breton",
     bs => "Bosnian",
     ca => "Catalan",
     ce => "Chechen",
     ch => "Chamorro",
     co => "Corsican",
     cs => "Czech",
     cu => "Church Slavic",
     cv => "Chuvash",
     cy => "Welsh",
     da => "Danish",
     de => "German",
     dz => "Dzongkha",
     el => "Greek",
     en => "English",
     eo => "Esperanto",
     es => "Spanish",
     et => "Estonian",
     eu => "Basque",
     fa => "Persian",
     fi => "Finnish",
     fj => "Fijian",
     fo => "Faeroese",
     fr => "French",
     fy => "Frisian",
     ga => "Irish",
     gd => "Gaelic (Scots)",
     gl => "Gallegan",
     gn => "Guarani",
     gu => "Gujarati",
     gv => "Manx",
     ha => "Hausa",
     he => "Hebrew",
     hi => "Hindi",
     ho => "Hiri Motu",
     hr => "Croatian",
     hu => "Hungarian",
     hy => "Armenian",
     hz => "Herero",
     ia => "Interlingua",
     id => "Indonesian",
     ie => "Interlingue",
     ik => "Inupiaq",
     is => "Icelandic",
     it => "Italian",
     iu => "Inuktitut",
     ja => "Japanese",
     jw => "Javanese",
     ka => "Georgian",
     ki => "Kikuyu",
     kj => "Kuanyama",
     kk => "Kazakh",
     kl => "Kalaallisut",
     km => "Khmer",
     kn => "Kannada",
     ko => "Korean",
     ks => "Kashmiri",
     ku => "Kurdish",
     kv => "Komi",
     kw => "Cornish",
     ky => "Kirghiz",
     la => "Latin",
     lb => "Letzeburgesch",
     ln => "Lingala",
     lo => "Lao",
     lt => "Lithuanian",
     lv => "Latvian",
     mg => "Malagasy",
     mh => "Marshall",
     mi => "Maori",
     mk => "FYRO Macedonian",
     ml => "Malayalam",
     mn => "Mongolian",
     mo => "Moldavian",
     mr => "Marathi",
     ms => "Malay",
     mt => "Maltese",
     my => "Burmese",
     na => "Nauru",
     nb => "Norwegian (Bokmål)",
     nd => "Ndebele, North",
     ne => "Nepali",
     ng => "Ndonga",
     nl => "Dutch",
     nn => "Norwegian-Nynorsk",
     no => "Norwegian-Nynorsk",
     nr => "Ndebele, South",
     nv => "Navajo",
     ny => "Chichewa",
     oc => "Occitan (post 1500)",
     om => "Oromo",
     or => "Oriya",
     os => "Ossetian",
     pa => "Panjabi",
     pi => "Pali",
     pl => "Polish",
     ps => "Pushto",
     pt => "Portuguese",
     qu => "Quechua",
     rm => "Rhaeto-Romance",
     rn => "Rundi",
     ro => "Romanian",
     ru => "Russian",
     rw => "Kinyarwanda",
     sa => "Sanskrit",
     sc => "Sardinian",
     sd => "Sindhi",
     se => "Sami",
     sg => "Sango",
     si => "Sinhalese",
     sk => "Slovak",
     sl => "Slovenian",
     sm => "Samoan",
     sn => "Shona",
     so => "Somali",
     sq => "Albanian",
     sr => "Serbian",
     ss => "Swati",
     st => "Sotho",
     su => "Sundanese",
     sv => "Swedish",
     sw => "Swahili",
     ta => "Tamil",
     te => "Telugu",
     tg => "Tajik",
     th => "Thai",
     ti => "Tigrinya",
     tk => "Turkmen",
     tl => "Tagalog",
     tn => "Tswana",
     to => "Tonga",
     tr => "Turkish",
     ts => "Tsonga",
     tt => "Tatar",
     tw => "Twi",
     ug => "Uighur",
     uk => "Ukrainian",
     ur => "Urdu",
     uz => "Uzbek",
     vi => "Vietnamese",
     vo => "Volapuk",
     wo => "Wolof",
     xh => "Xhosa",
     yi => "Yiddish",
     yo => "Yoruba",
     za => "Zhuang",
     zh => "Chinese",
     zu => "Zulu",
 };
 
 use constant WIN32COUNTRY => {
     ad => "Andorra",
     ae => "United Arab Emirates",
     af => "Afghanistan",
     ag => "Antigua and Barbuda",
     ai => "Anguilla",
     al => "Albania",
     am => "Armenia",
     an => "Netherlands Antilles",
     ao => "Angola",
     aq => "Antarctica",
     ar => "Argentina",
     as => "American Samoa",
     at => "Austria",
     au => "Australia",
     aw => "Aruba",
     ax => "Aland Islands",
     az => "Azerbaijan",
     ba => "Bosnia and Herzegovina",
     bb => "Barbados",
     bd => "Bangladesh",
     be => "Belgium",
     bf => "Burkina Faso",
     bg => "Bulgaria",
     bh => "Bahrain",
     bi => "Burundi",
     bj => "Benin",
     bm => "Bermuda",
     bn => "Brunei Darussalam",
     bo => "Bolivia",
     br => "Brazil",
     bs => "Bahamas",
     bt => "Bhutan",
     bv => "Bouvet Island",
     bw => "Botswana",
     by => "Belarus",
     bz => "Belize",
     ca => "Canada",
     cc => "Cocos (Keeling) Islands",
     cd => "Congo, The Democratic Republic of the",
     cf => "Central African Republic",
     cg => "Congo",
     ch => "Switzerland",
     ci => "Cote D'Ivoire",
     ck => "Cook Islands",
     cl => "Chile",
     cm => "Cameroon",
     cn => "China",
     co => "Colombia",
     cr => "Costa Rica",
     cs => "Serbia and Montenegro",
     cu => "Cuba",
     cv => "Cape Verde",
     cx => "Christmas Island",
     cy => "Cyprus",
     cz => "Czech Republic",
     de => "Germany",
     dj => "Djibouti",
     dk => "Denmark",
     dm => "Dominica",
     do => "Dominican Republic",
     dz => "Algeria",
     ec => "Ecuador",
     ee => "Estonia",
     eg => "Egypt",
     eh => "Western Sahara",
     er => "Eritrea",
     es => "Spain",
     et => "Ethiopia",
     fi => "Finland",
     fj => "Fiji",
     fk => "Falkland Islands (Malvinas)",
     fm => "Micronesia, Federated States of",
     fo => "Faroe Islands",
     fr => "France",
     fx => "France, Metropolitan",
     ga => "Gabon",
     gb => "United Kingdom",
     gd => "Grenada",
     ge => "Georgia",
     gf => "French Guiana",
     gh => "Ghana",
     gi => "Gibraltar",
     gl => "Greenland",
     gm => "Gambia",
     gn => "Guinea",
     gp => "Guadeloupe",
     gq => "Equatorial Guinea",
     gr => "Greece",
     gs => "South Georgia and the South Sandwich Islands",
     gt => "Guatemala",
     gu => "Guam",
     gw => "Guinea-Bissau",
     gy => "Guyana",
     hk => "Hong Kong",
     hm => "Heard Island and McDonald Islands",
     hn => "Honduras",
     hr => "Croatia",
     ht => "Haiti",
     hu => "Hungary",
     id => "Indonesia",
     ie => "Ireland",
     il => "Israel",
     in => "India",
     io => "British Indian Ocean Territory",
     iq => "Iraq",
     ir => "Iran",
     is => "Iceland",
     it => "Italy",
     jm => "Jamaica",
     jo => "Jordan",
     jp => "Japan",
     ke => "Kenya",
     kg => "Kyrgyzstan",
     kh => "Cambodia",
     ki => "Kiribati",
     km => "Comoros",
     kn => "Saint Kitts and Nevis",
     kp => "North-Korea",
     kr => "Korea",
     kw => "Kuwait",
     ky => "Cayman Islands",
     kz => "Kazakhstan",
     la => "Laos",
     lb => "Lebanon",
     lc => "Saint Lucia",
     li => "Liechtenstein",
     lk => "Sri Lanka",
     lr => "Liberia",
     ls => "Lesotho",
     lt => "Lithuania",
     lu => "Luxembourg",
     lv => "Latvia",
     ly => "Libyan",
     ma => "Morocco",
     mc => "Monaco",
     md => "Moldova",
     mg => "Madagascar",
     mh => "Marshall Islands",
     mk => "Former Yugoslav Republic of Macedonia",
     ml => "Mali",
     mm => "Myanmar",
     mn => "Mongolia",
     mo => "Macao",
     mp => "Northern Mariana Islands",
     mq => "Martinique",
     mr => "Mauritania",
     ms => "Montserrat",
     mt => "Malta",
     mu => "Mauritius",
     mv => "Maldives",
     mw => "Malawi",
     mx => "Mexico",
     my => "Malaysia",
     mz => "Mozambique",
     na => "Namibia",
     nc => "New Caledonia",
     ne => "Niger",
     nf => "Norfolk Island",
     ng => "Nigeria",
     ni => "Nicaragua",
     nl => "Netherlands",
     no => "Norway",
     np => "Nepal",
     nr => "Nauru",
     nu => "Niue",
     nz => "New Zealand",
     om => "Oman",
     pa => "Panama",
     pe => "Peru",
     pf => "French Polynesia",
     pg => "Papua New Guinea",
     ph => "Philippines",
     pk => "Pakistan",
     pl => "Poland",
     pm => "Saint Pierre and Miquelon",
     pn => "Pitcairn",
     pr => "Puerto Rico",
     ps => "Palestinian Territory, Occupied",
     pt => "Portugal",
     pw => "Palau",
     py => "Paraguay",
     qa => "Qatar",
     re => "Reunion",
     ro => "Romania",
     ru => "Russian Federation",
     rw => "Rwanda",
     sa => "Saudi Arabia",
     sb => "Solomon Islands",
     sc => "Seychelles",
     sd => "Sudan",
     se => "Sweden",
     sg => "Singapore",
     sh => "Saint Helena",
     si => "Slovenia",
     sj => "Svalbard and Jan Mayen",
     sk => "Slovakia",
     sl => "Sierra Leone",
     sm => "San Marino",
     sn => "Senegal",
     so => "Somalia",
     sr => "Suriname",
     st => "Sao Tome and Principe",
     sv => "El Salvador",
     sy => "Syrian Arab Republic",
     sz => "Swaziland",
     tc => "Turks and Caicos Islands",
     td => "Chad",
     tf => "French Southern Territories",
     tg => "Togo",
     th => "Thailand",
     tj => "Tajikistan",
     tk => "Tokelau",
     tl => "Timor-Leste",
     tm => "Turkmenistan",
     tn => "Tunisia",
     to => "Tonga",
     tr => "Turkey",
     tt => "Trinidad and Tobago",
     tv => "Tuvalu",
     tw => "Taiwan, Province of China",
     tz => "Tanzania, United Republic of",
     ua => "Ukraine",
     ug => "Uganda",
     um => "United States Minor Outlying Islands",
     us => "United States",
     uy => "Uruguay",
     uz => "Uzbekistan",
     va => "Holy See (Vatican City State)",
     vc => "Saint Vincent and the Grenadines",
     ve => "Venezuela",
     vg => "Virgin Islands, British",
     vi => "Virgin Islands, U.S.",
     vn => "Vietnam",
     vu => "Vanuatu",
     wf => "Wallis and Futuna",
     ws => "Samoa",
     ye => "Yemen",
     yt => "Mayotte",
     za => "South Africa",
     zm => "Zambia",
     zw => "Zimbabwe",
 };
 
 my $locale_cache;
 
 sub parse_http_accept_language {
 	my ($string) = @_;
 
 	my @tokens = split / *, */, $string;
 	
 	my %retval;
 	foreach my $token (@tokens) {
 		my $quality = 1;
 		if ($token =~ s/ *; *q *= *([0-9]+(?:\.([0-9]+))?)$//) {
 			$quality = $1;
 		}
 		$retval{$token} = $quality;
 	}
 
 	return grep { 
 		/^[A-Za-z]+(?:-[A-Za-z]+)?$/
 		} map {
 			$_ = 'C' if $_ eq '*'; $_
 		}	sort { 
 			$retval{$b} <=> $retval{$a} 
 		} keys %retval;
 }
 
 sub parse_http_accept_charset {
 	my ($string) = @_;
 
 	my @tokens = split / *, */, $string;
 	
 	my %retval;
 	foreach my $token (@tokens) {
 		my $quality = 1;
 		if ($token =~ s/ *; *q *= *([0-9]+(?:\.([0-9]+))?)$//) {
 			$quality = $1;
 		}
 		$retval{$token} = $quality;
 	}
 
 	return grep { 
 		/^[-!\#\$\%\&\'\+\.0-9A-Z_\`a-z\|\~]+$/
 		} map {
 			$_ = undef if $_ eq '*'; $_
 		}	sort { 
 			$retval{$b} <=> $retval{$a} 
 		} keys %retval;
 }
 
 sub set_locale {
 	my ($category, $language, $country, $charset) = @_;
 	
 	require POSIX;
 
     $country = '' unless defined $country;
     $charset = '' unless defined $charset;
     
 	my $set_locale;
     if (my $retval = $locale_cache->{$language}->{$country}->{$charset}) {
     	my ($locale, $country) = @$retval;
 	POSIX::setlocale ($category, $locale);
         return @$retval;
     }
 
 	$locale_cache->{$language}->{$country}->{$charset} = undef;
 
 	my $windows = ($^O !~ /darwin/i && $^O =~ /win/i) ? 1 : 0;
 	if ($windows) {
 		return &__set_locale_windows;
 	}
 	
 	my $set_language;
 	my $set_country;
 
 	my @languages = ($language);
 	my @lc_languages = map { lc $_ } @languages;
 	my @uc_languages = map { uc $_ } @languages;
 	my %seen = ();
 
 	foreach my $language (@languages, @lc_languages, @uc_languages) {
 		next if $seen{$language}++;
 		warn "Trying lingua only setlocale '$language'.\n" if DEBUG;
 		my $result = POSIX::setlocale ($category, $language);
 		if ($result) {
 			$set_locale = $set_language = $result if $result;
 			last;
 		}
 	}
 
 	my @countries = length $country ? ($country) : ();
 	my @uc_countries = map { uc $_ } @countries;
 	my @lc_countries = map { uc $_ } @countries;
 	push @countries, @uc_countries, @lc_countries;
  
  LINGUA: foreach my $language (@languages, @lc_languages, @uc_languages) {
 		my $count = 0;
 		my @guessed_countries = (LANG2COUNTRY->{lc $language},
 								 lc LANG2COUNTRY->{lc $language},
 								 uc LANG2COUNTRY->{lc $language});
 		foreach my $c (@countries, @guessed_countries) {
 			++$count;
 			next unless defined $c && length $c;
 			my $try = $language . '_' . $c;
 			next if $seen{$try}++;
 			warn "Trying setlocale '$try'.\n" if DEBUG;
 			my $result = POSIX::setlocale ($category, $try);
 			if ($result) {
 				$set_locale = $result;
 				if ($count >= @countries) {
 					$set_country = $c; 
 				} else {
 					$set_country = $country;
 				}
 
 				last LINGUA;
 			}
 		}
 	}
 	
 	unless (length $charset) {
 		return unless defined $set_locale && length $set_locale;
 		
 		$locale_cache->{$language}->{$country}->{$charset} = 
 			[$set_locale, $set_country];
 		return wantarray ? ($set_locale, $set_country) : $set_locale;
 	}
 	
 	my @charsets = ($charset);
 	my $cleaned = $charset;
 	push @charsets, $cleaned if $cleaned =~ s/-//g;
 	my @lc_charsets = map { lc $charset } @charsets;
 	my @uc_charsets = map { uc $charset } @charsets;
 	push @charsets, @lc_charsets, @uc_charsets;
 	
 	%seen = ();
  LINGUA2: foreach my $language (@languages, 
 								@lc_languages, @uc_languages) {
 	     my @guessed_countries = (LANG2COUNTRY->{lc $language},
 								 lc LANG2COUNTRY->{lc $language},
 								 uc LANG2COUNTRY->{lc $language});
 	     my $count = 0;
 		 foreach my $c (@countries, @guessed_countries) {
 			 ++$count;
 			 $c = '' unless defined $c && length $c;
 			 my $country_try = $language;
 			 $country_try .= (length $c) ? "_$c" : '';
 			 
 			 foreach my $ch (@charsets, @lc_charsets, @uc_charsets) {
 				 my $try = $country_try . '.' . $ch;
 				 next if $seen{$try}++;
 				 warn "Trying setlocale '$try'.\n" if DEBUG;
 				 
 				 my $result = POSIX::setlocale ($category, $try);
 				 if ($result) {
 					 $set_locale = $result;
 					 if ($count >= @countries) {
 						 $set_country = $c; 
 					 } else {
 						 $set_country = $country;
 					 }
 					 
 					 last LINGUA2;
 				 }
 			 }
 		 } 
 	 }
 
 	return unless defined $set_locale && length $set_locale;
 
 	$locale_cache->{$language}->{$country}->{$charset} = 
 		[$set_locale, $set_country];
 
 	return wantarray ? ($set_locale, $set_country) : $set_locale;
 }
 
 sub __set_locale_windows {
 	my ($category, $language, $country, $charset) = @_;
 
     my $set_locale;
 
     $country = '' unless defined $country;
     $charset = '' unless defined $charset;
     	
 	my $long_language = WIN32LANGUAGE->{lc $language};
 	my @languages = ($long_language, $language);
 	my %seen = ();
 	foreach my $language (@languages) {
 		next if $seen{$language}++;
 		warn "Trying lingua only setlocale '$language'.\n" if DEBUG;
 		my $result = POSIX::setlocale ($category, $language);
 		if ($result) {
 			$set_locale = $result if $result;
 			last;
 		}
 	}
 	
 	my $set_country;
 	if (length $country) {
         COMBI: foreach my $language (@languages) {
 	        my @short_countries = ($country);
 		    my @countries = map { 
 			    WIN32COUNTRY->{lc $_} 
 			    } grep { length $_ } @short_countries;
 		    foreach my $c (@countries) {
 			    next unless defined $c && length $c;
 			    my $try = $language . '_' . $c;
 			    next if $seen{$try}++;
 			    warn "Trying setlocale '$try'.\n" if DEBUG;
 			    my $result = POSIX::setlocale ($category, $try);
 			    if ($result) {
 				    $set_locale = $result;
 					$set_country = $c;
 				    last COMBI;
 			    }
 		    }
 	    }
 	}
 
 	return unless defined $set_locale && length $set_locale;
 
 	$locale_cache->{$language}->{$country}->{$charset} = 
 		[$set_locale, $set_country];
 	return wantarray ? ($set_locale, $set_country) : $set_locale;
 }
 
 sub get_locale_cache {
 	$locale_cache;
 }
 
 sub set_locale_cache {
 	if (ref $_[0] && 'HASH' eq ref $_[0]) {
 		$locale_cache = $_[0];
     } else {
 		my %locale_cache = @_;
 		$locale_cache = \%locale_cache;
 	}
 }
 
 sub web_set_locale {
 	my ($accept_language, $accept_charset, $category, $available) = @_;
 
 	my %available;
 	if ($available) {
 		foreach (@$available) {
 			my $locale = $_;
 			$locale =~ s/[_\@\.].*//;
 			$available{lc $locale} = 1;
 		}
 	}
 
 	my @languages;
 	if (ref $accept_language && 'ARRAY' eq ref $accept_language) {
 		@languages = @$accept_language;
 	} else {
 		@languages = parse_http_accept_language $accept_language;
 	}
 
 	if ($available) {
 		my @all = @languages;
 		@languages = ();
 		foreach my $locale (@all) {
 			my $language = lc $locale;
 			$language =~ s/[_\@\.].*//;
 			push @languages, $locale if $available{$language};
 		}
 	}
 
 	my @charsets;
 	if (defined $accept_charset) {
 		if (ref $accept_charset && 'ARRAY' eq ref $accept_charset) {
 			@charsets = @$accept_charset;
 		} else {
 			@charsets = parse_http_accept_charset $accept_charset;
 		}
 	}
 
 	unless (defined $category) {
 		require POSIX;
 		$category = POSIX::LC_ALL();
 	}
 
 	my ($set_locale, $set_language, $set_country, $set_charset);
 	foreach my $lang (@languages) {
 		my ($language, $country) = split /-/, $lang, 2;
 
 		my ($locale, $country_used) = 
 			set_locale ($category, $language, $country, $charsets[0]);
 		
 		if (defined $locale) {
 			if (defined $country) {
 				if (!defined $country
 					|| ($country ne $country_used)) {
 					$set_language = $language;
 					$set_locale = $locale;
 					$set_country = $country_used;
 					$set_charset = $charsets[0];
 				}
 			}
 
 			if (wantarray) {
 				return $locale, $lang, $country_used, $charsets[0];
 			} else {
 				return $locale;
 			}
 		}
 	}
 	
 	if (defined $set_locale) {
 		if (wantarray) {
 			return $set_locale, $set_language, $set_country, $set_charset;
 		} else {
 			return $set_locale;
 		}
 	}
 
 	return;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 cperl-indent-level: 4
 cperl-continued-statement-offset: 2
 tab-width: 4
 End:
### Locale/gettext_dumb.pm ###
 #! /bin/false
 
 
 
 
 
 
 package Locale::gettext_dumb;
 
 use Locale::gettext_pp;
 
 use vars qw (%EXPORT_TAGS @EXPORT_OK @ISA $VERSION);
 
 %EXPORT_TAGS = (locale_h => [ qw (gettext
                                   dgettext
                                   dcgettext
                                   ngettext
                                   dngettext
                                   dcngettext
                                   pgettext
                                   dpgettext
                                   dcpgettext
                                   npgettext
                                   dnpgettext
                                   dcnpgettext
                                   textdomain
                                   bindtextdomain
                                   bind_textdomain_codeset
                                   )],
                 libintl_h => [ qw (LC_CTYPE
                                    LC_NUMERIC
                                    LC_TIME
                                    LC_COLLATE
                                    LC_MONETARY
                                    LC_MESSAGES
                                    LC_ALL)],
                 );
 
 @EXPORT_OK = qw (gettext
                  dgettext
                  dcgettext
                  ngettext
                  dngettext
                  dcngettext
                  pgettext
                  dpgettext
                  dcpgettext
                  npgettext
                  dnpgettext
                  dcnpgettext
                  textdomain
                  bindtextdomain
                  bind_textdomain_codeset
                  nl_putenv
                  setlocale
                  LC_CTYPE
                  LC_NUMERIC
                  LC_TIME
                  LC_COLLATE
                  LC_MONETARY
                  LC_MESSAGES
                  LC_ALL);
                  
 @ISA = qw (Exporter);
 
 *Locale::gettext_dumb::textdomain = \&Locale::gettext_pp::textdomain;
 *Locale::gettext_dumb::bindtextdomain = \&Locale::gettext_pp::bindtextdomain;
 *Locale::gettext_dumb::bind_textdomain_codeset = 
     \&Locale::gettext_pp::bind_textdomain_codeset;
 
 *Locale::gettext_dumb::nl_putenv = \&Locale::gettext_pp::nl_putenv;
 
 *Locale::gettext_dumb::LC_CTYPE = \&Locale::gettext_pp::LC_CTYPE;
 *Locale::gettext_dumb::LC_NUMERIC = \&Locale::gettext_pp::LC_NUMERIC;
 *Locale::gettext_dumb::LC_TIME= \&Locale::gettext_pp::LC_TIME;
 *Locale::gettext_dumb::LC_COLLATE = \&Locale::gettext_pp::LC_COLLATE;
 *Locale::gettext_dumb::LC_MONETARY = \&Locale::gettext_pp::LC_MONETARY;
 *Locale::gettext_dumb::LC_MESSAGES = \&Locale::gettext_pp::LC_MESSAGES;
 *Locale::gettext_dumb::LC_ALL = \&Locale::gettext_pp::LC_ALL;
 
 
 sub gettext ($) {
     my ($msgid) = @_;
 
     return dcnpgettext ('', undef, $msgid, undef, undef, undef);
 }
 
 sub dgettext ($$) {
     my ($domainname, $msgid) = @_;
 
     return dcnpgettext ($domainname, undef, $msgid, undef, undef, undef);
 }
 
 sub dcgettext ($$$) {
     my ($domainname, $msgid, $category) = @_;
 
     return dcnpgettext ($domainname, undef, $msgid, undef, undef, undef);
 }
 
 sub ngettext ($$$) {
     my ($msgid, $msgid_plural, $n) = @_;
 
     return dcnpgettext ('', undef, $msgid, $msgid_plural, $n, undef);
 }
 
 sub dngettext ($$$$) {
     my ($domainname, $msgid, $msgid_plural, $n) = @_;
 
     return dcnpgettext ($domainname, undef, $msgid, $msgid_plural, $n, undef);
 }
 
 sub dcngettext ($$$$$) {
     my ($domainname, $msgid, $msgid_plural, $n, $category) = @_;
 
     return dcnpgettext ($domainname, undef, $msgid, $msgid_plural, $n, , 
                         $category);
 }
 
 sub pgettext ($$) {
     my ($msgctxt, $msgid) = @_;
 
     return dcnpgettext ('', $msgctxt, $msgid, undef, undef, undef);
 }
 
 sub dpgettext ($$$) {
     my ($domainname, $msgctxt, $msgid) = @_;
 
     return dcnpgettext ($domainname, $msgctxt, $msgid, undef, undef, undef);
 }
 
 sub dcpgettext($$$$) {
     my ($domainname, $msgctxt, $msgid, $category) = @_;
 
     return dcnpgettext ($domainname, $msgctxt, $msgid, undef, undef, undef);
 }
 
 sub npgettext ($$$$) {
     my ($msgctxt, $msgid, $msgid_plural, $n) = @_;
 
     return dcnpgettext ('', $msgctxt, $msgid, $msgid_plural, $n, undef);
 }
 
 sub dnpgettext ($$$$$) {
     my ($domainname, $msgctxt, $msgid, $msgid_plural, $n) = @_;
 
     return dcnpgettext ($domainname, $msgctxt, $msgid, $msgid_plural, $n, undef);
 }
 
 sub dcnpgettext ($$$$$$) {
     my ($domainname, $msgctxt, $msgid, $msgid_plural, $n, $category) = @_;
 
     my $locale;
 
     if (exists $ENV{LANGUAGE} && length $ENV{LANGUAGE}) {
         $locale = $ENV{LANGUAGE};
         $locale =~ s/:.*//s;
     } elsif (exists $ENV{LC_ALL} && length $ENV{LC_ALL}) {
         $locale = $ENV{LC_ALL};
     } elsif (exists $ENV{LANG} && length $ENV{LANG}) {
         $locale = $ENV{LANG};
     } elsif (exists $ENV{LC_MESSAGES} && length $ENV{LC_MESSAGES}) {
         $locale = $ENV{LC_MESSAGES};
     } else {
         $locale = 'C';
     }
     
     return Locale::gettext_pp::_dcnpgettext_impl ($domainname, $msgctxt,
                                                   $msgid, $msgid_plural, $n,
                                                   $category, $locale);
 }
 
 sub setlocale($;$) {
 	&POSIX::setlocale;
 }
 
 1;
 
 __END__
 
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 tab-width: 4
 End:
### Locale/gettext_pp.pm ###
 #! /bin/false
 
 
 
 
 
 
 package Locale::gettext_pp;
 
 use strict;
 
 require 5.004;
 
 use vars qw ($__gettext_pp_default_dir 
     		 $__gettext_pp_textdomain
     		 $__gettext_pp_domain_bindings
     		 $__gettext_pp_domain_codeset_bindings
     		 $__gettext_pp_domains
     		 $__gettext_pp_recoders
     		 $__gettext_pp_unavailable_dirs
     		 $__gettext_pp_domain_cache
     		 $__gettext_pp_alias_cache
     		 $__gettext_pp_context_glue);
 
 use locale;
 use File::Spec;
 
 BEGIN {
     $__gettext_pp_textdomain = 'messages';
     $__gettext_pp_domain_bindings = {};
     $__gettext_pp_domain_codeset_bindings = {};
     $__gettext_pp_domains = {};
     $__gettext_pp_recoders = {};
     $__gettext_pp_unavailable_dirs = {};
     $__gettext_pp_domain_cache = {};
     $__gettext_pp_alias_cache = {};
     $__gettext_pp_context_glue = "\004";
     
     $__gettext_pp_default_dir = '';
     
     for my $dir (qw (/usr/share/locale /usr/local/share/locale)) {
     	if (-d $dir) {
     		$__gettext_pp_default_dir = $dir;
     		last;
     	}
     }
 }
 
 BEGIN {
     	require POSIX;
     	require Exporter;
     	use IO::Handle;
     	require Locale::Recode;
 
     	local $@;
     	my ($has_messages, $five_ok);
     	
     	$has_messages = eval '&POSIX::LC_MESSAGES';
 
     	unless (defined $has_messages && length $has_messages) {
     			$five_ok = ! grep {my $x = eval "&POSIX::$_" || 0; $x eq '5';}
     							qw (LC_CTYPE
     							   LC_NUMERIC
     							   LC_TIME
     							   LC_COLLATE
     							   LC_MONETARY
     							   LC_ALL);
     		if ($five_ok) {
     			$five_ok = POSIX::setlocale (5, '');
     		}
     	}
     	
     	if (defined $has_messages && length $has_messages) {
 eval <<'EOF';
 sub LC_MESSAGES()
 {
     local $!; # Do not clobber errno!
     
     return &POSIX::LC_MESSAGES;
 }
 EOF
     	} elsif ($five_ok) {
 eval <<'EOF';
 sub LC_MESSAGES()
 {
     local $!; # Do not clobber errno!
 
     # Hack: POSIX.pm deems LC_MESSAGES an invalid macro until
     # Perl 5.8.0.  However, on LC_MESSAGES should be 5 ...
     return 5;
 }
 EOF
     	} else {
 eval <<'EOF';
 sub LC_MESSAGES()
 {
     local $!; # Do not clobber errno!
 
     # This fallback value is widely used,
     # when LC_MESSAGES is not available.
     return 1729;
 }
 EOF
     	}
 }
 
 use vars qw (%EXPORT_TAGS @EXPORT_OK @ISA $VERSION);
 
 %EXPORT_TAGS = (locale_h => [ qw (
     							  gettext
     							  dgettext
     							  dcgettext
     							  ngettext
     							  dngettext
     							  dcngettext
     							  pgettext
     							  dpgettext
     							  dcpgettext
     							  npgettext
     							  dnpgettext
     							  dcnpgettext
     							  textdomain
     							  bindtextdomain
     							  bind_textdomain_codeset
     							  )
     						  ],
     			libintl_h => [ qw (LC_CTYPE
     							   LC_NUMERIC
     							   LC_TIME
     							   LC_COLLATE
     							   LC_MONETARY
     							   LC_MESSAGES
     							   LC_ALL)
     						   ],
     			);
 
 @EXPORT_OK = qw (gettext
     			 dgettext
     			 dcgettext
     			 ngettext
     			 dngettext
     			 dcngettext
     			 pgettext
     			 dpgettext
     			 dcpgettext
     			 npgettext
     			 dnpgettext
     			 dcnpgettext
     			 textdomain
     			 bindtextdomain
     			 bind_textdomain_codeset
                  nl_putenv
                  setlocale
     			 LC_CTYPE
     			 LC_NUMERIC
     			 LC_TIME
     			 LC_COLLATE
     			 LC_MONETARY
     			 LC_MESSAGES
     			 LC_ALL);
 @ISA = qw (Exporter);
 
 my $has_nl_langinfo;
 
 sub __load_catalog;
 sub __load_domain;
 sub __locale_category;
 sub __untaint_plural_header;
 sub __compile_plural_function;
 
 sub LC_NUMERIC()
 {
     &POSIX::LC_NUMERIC;
 }
 
 sub LC_CTYPE()
 {
     &POSIX::LC_CTYPE;
 }
 
 sub LC_TIME()
 {
     &POSIX::LC_TIME;
 }
 
 sub LC_COLLATE()
 {
     &POSIX::LC_COLLATE;
 }
 
 sub LC_MONETARY()
 {
     &POSIX::LC_MONETARY;
 }
 
 sub LC_ALL()
 {
     &POSIX::LC_ALL;
 }
 
 sub textdomain(;$)
 {
     my $new_domain = shift;
     
     $__gettext_pp_textdomain = $new_domain if defined $new_domain && 
     	length $new_domain;
     
     return $__gettext_pp_textdomain;
 }
 
 sub bindtextdomain($;$)
 {
     my ($domain, $directory) = @_;
 
     my $retval;	
     if (defined $domain && length $domain) {
     	if (defined $directory && length $directory) {
     		$retval = $__gettext_pp_domain_bindings->{$domain} 
     			= $directory;
     	} elsif (exists $__gettext_pp_domain_bindings->{$domain}) {
     		$retval = $__gettext_pp_domain_bindings->{$domain};
     	} else {
     		$retval = $__gettext_pp_default_dir;
     	}
     	$retval = '/usr/share/locale' unless defined $retval && 
     		length $retval;
     	return $retval;
     } else {
     	return;
     }
 }
 
 sub bind_textdomain_codeset($;$)
 {
     my ($domain, $codeset) = @_;
     
     if (defined $domain && length $domain) {
     	if (defined $codeset && length $codeset) {
     		return $__gettext_pp_domain_codeset_bindings->{$domain} = $codeset;
     	} elsif (exists $__gettext_pp_domain_codeset_bindings->{$domain}) {
     		return $__gettext_pp_domain_codeset_bindings->{$domain};
     	}
     }
     
     return;
 }
 
 sub gettext($)
 {
     my ($msgid) = @_;
 
     return dcnpgettext ('', undef, $msgid, undef, undef, undef);
 }
 
 sub dgettext($$)
 {
     my ($domainname, $msgid) = @_;
 
     return dcnpgettext ($domainname, undef, $msgid, undef, undef, undef);
 }
 
 sub dcgettext($$$)
 {
     my ($domainname, $msgid, $category) = @_;
 
     return dcnpgettext ($domainname, undef, $msgid, undef, undef, undef);
 }
 
 sub ngettext($$$)
 {
     my ($msgid, $msgid_plural, $n) = @_;
 
     return dcnpgettext ('', undef, $msgid, $msgid_plural, $n, undef);
 }
 
 sub dngettext($$$$)
 {
     my ($domainname, $msgid, $msgid_plural, $n) = @_;
 
     return dcnpgettext ($domainname, undef, $msgid, $msgid_plural, $n, undef);
 }
 
 sub dcngettext($$$$$)
 {
     my ($domainname, $msgid, $msgid_plural, $n, $category) = @_;
 
     return dcnpgettext ($domainname, undef, $msgid, $msgid_plural, $n, , $category);
 }
 
 
 sub pgettext($$)
 {
     my ($msgctxt, $msgid) = @_;
 
     return dcnpgettext ('', $msgctxt, $msgid, undef, undef, undef);
 }
 
 sub dpgettext($$$)
 {
     my ($domainname, $msgctxt, $msgid) = @_;
 
     return dcnpgettext ($domainname, $msgctxt, $msgid, undef, undef, undef);
 }
 
 sub dcpgettext($$$$)
 {
     my ($domainname, $msgctxt, $msgid, $category) = @_;
 
     return dcnpgettext ($domainname, $msgctxt, $msgid, undef, undef, undef);
 }
 
 sub npgettext($$$$)
 {
     my ($msgctxt, $msgid, $msgid_plural, $n) = @_;
 
     return dcnpgettext ('', $msgctxt, $msgid, $msgid_plural, $n, undef);
 }
 
 sub dnpgettext($$$$$)
 {
     my ($domainname, $msgctxt, $msgid, $msgid_plural, $n) = @_;
 
     return dcnpgettext ($domainname, $msgctxt, $msgid, $msgid_plural, $n, undef);
 }
 
 sub _dcnpgettext_impl {
     my ($domainname, $msgctxt, $msgid, $msgid_plural, $n, $category,
         $locale) = @_;
 
     return unless defined $msgid;
 
     my $plural = defined $msgid_plural;
     my $msg_ctxt_id = defined $msgctxt ? join($__gettext_pp_context_glue, ($msgctxt, $msgid)) : $msgid;
     
     local $!; 
     
     $domainname = $__gettext_pp_textdomain
     	unless defined $domainname && length $domainname;
     
     my $category_name = 'LC_MESSAGES';
     $category = LC_MESSAGES;
 
     my $domains = __load_domain ($domainname, $category, $category_name,
                                  $locale);
     
     my @trans = ();
     my $domain;
     my $found;
     foreach my $this_domain (@$domains) {
     	if ($this_domain && defined $this_domain->{messages}->{$msg_ctxt_id}) {
     		@trans = @{$this_domain->{messages}->{$msg_ctxt_id}};
     		shift @trans;
     		$domain = $this_domain;
     		$found = 1;
     		last;
     	}
     }
     @trans = ($msgid, $msgid_plural) unless @trans;
     
     my $trans = $trans[0];
     if ($plural) {
     	if ($domain) {
     		my $nplurals = 0;
     		($nplurals, $plural) = &{$domain->{plural_func}} ($n);
     		$plural = 0 unless defined $plural;
     		$nplurals = 0 unless defined $nplurals;
     		$plural = 0 if $nplurals <= $plural;
     	} else {
     		$plural = $n != 1 || 0;
     	}
     	
     	$trans = $trans[$plural] if defined $trans[$plural];
     }
     
     if ($found && defined $domain->{po_header}->{charset}) {
     	my $input_codeset = $domain->{po_header}->{charset};
     	my $output_codeset = $__gettext_pp_domain_codeset_bindings->{$domainname};
 
     	$output_codeset = $ENV{OUTPUT_CHARSET} unless defined $output_codeset;
     	$output_codeset = __get_codeset ($category, $category_name,
     									 $domain->{locale_id})
     		unless defined $output_codeset;
     	
     	unless (defined $output_codeset) {
     		my $lc_ctype = __locale_category (POSIX::LC_CTYPE(), 
     									   'LC_CTYPE');
     		$output_codeset = $1
     			if $lc_ctype =~ /^[a-z]{2}(?:_[A-Z]{2})?\.([^@]+)/;
     	}
 
     	$output_codeset = $domain->{po_header}->{charset}
     		unless defined $output_codeset;
     
     	if (exists $__gettext_pp_domain_cache->{$output_codeset}) {
     		$output_codeset = $__gettext_pp_domain_cache->{$output_codeset};
     	} else {
     		$output_codeset = 'utf-8' if lc $output_codeset eq 'utf8';
     		$output_codeset = 
     			$__gettext_pp_domain_cache->{$output_codeset} =
     			Locale::Recode->resolveAlias ($output_codeset);
     	}
     	
     	if (defined $output_codeset &&
     		$output_codeset ne $domain->{po_header}->{charset}) {
     		my $recoder;
     		
     		if (exists 
     			$__gettext_pp_recoders->{$input_codeset}->{$output_codeset}) {
     			$recoder = $__gettext_pp_recoders->{$input_codeset}->{$output_codeset};
     		} else {
     			$recoder = 
     				$__gettext_pp_recoders->{$input_codeset}->{$output_codeset} =
     				Locale::Recode->new (from => $input_codeset,
     									 to => $output_codeset,
     									 );
     		}
     		
     		$recoder->recode ($trans);
     	}
     }
     
     return $trans;
 }
 
 sub dcnpgettext ($$$$$$) {
     return &_dcnpgettext_impl;
 }
 
 sub nl_putenv ($)
 {
     my ($envspec) = @_;
     return unless defined $envspec;
     return unless length $envspec;
     return if substr ($envspec, 0, 1) eq '=';
     
     my ($var, $value) = split /=/, $envspec, 2;
 
     if ($^O eq 'MSWin32') {
         $value = '' unless defined $value;
         if (length $value) {
             $ENV{$var} = $value;
         } else {
             delete $ENV{$var};
         }
     } else {
         if (defined $value) {
             $ENV{$var} = $value;
         } else {
             delete $ENV{$var};
         }
     }
 
     return 1;
 }
 
 sub setlocale($;$) {
 	require POSIX;
 	&POSIX::setlocale;
 }
 
 sub __load_domain
 {
     my ($domainname, $category, $category_name, $locale) = @_;
 
         if ($category != LC_MESSAGES) {
             return [];
         }
         
         if (!defined $locale && $category != 1729) {
                 $locale = POSIX::setlocale ($category);
                 if (!defined $locale || 'C' eq $locale || 'POSIX' eq $locale) {
                         return [];
                 }
         }
     
     $domainname = $__gettext_pp_textdomain
     	unless defined $domainname && length $domainname;
 
     my $dir = bindtextdomain ($domainname, '');
     $dir = $__gettext_pp_default_dir unless defined $dir && length $dir;
     return [] unless defined $dir && length $dir;
 
     my @locales;
     my $cache_key;
 
     if (defined $ENV{LANGUAGE} && length $ENV{LANGUAGE}) {
     	@locales = split /:/, $ENV{LANGUAGE};
     	$cache_key = $ENV{LANGUAGE};
     } elsif (!defined $locale) {
     	@locales = $cache_key = __locale_category ($category, 
     	                                           $category_name);
     } else {
             @locales = $cache_key = $locale;
     }
 
     my $domains = $__gettext_pp_domain_cache->{$dir}->{$cache_key}->{$category_name}->{$domainname};
     return $domains if defined $domains;
     return [] unless @locales;
     
     my @dirs = ($dir);
     my @tries = (@locales);
     my %locale_lookup = map { $_ => $_ } @tries;
 
     foreach my $locale (@locales) {
     	if ($locale =~ /^([a-z][a-z])
     		(?:(_[A-Z][A-Z])?
     		 (\.[-_A-Za-z0-9]+)?
     		 )?
     		(\@[-_A-Za-z0-9]+)?$/x) {
     		
     		if (defined $3) {
     			defined $2 ?
     				push @tries, $1 . $2 . $3 : push @tries, $1 . $3;
     		}
     		if (defined $2) {
     			push @tries, $1 . $2;
     			$locale_lookup{$1 . $2} = $locale;
     		}
     		if (defined $1) {
     			push @tries, $1 if defined $1;
     			$locale_lookup{$1} = $locale;
     		}
     	}
     }
     	push @dirs, $__gettext_pp_default_dir
     	if $__gettext_pp_default_dir && $dir ne $__gettext_pp_default_dir;
     
     my %seen = ();
     foreach my $basedir (@dirs) {
     	foreach my $try (@tries) {
     		my $fulldir = "$basedir/$try/$category_name";
     		
     		next if $seen{$fulldir}++;
 
     		next if $__gettext_pp_unavailable_dirs->{$fulldir};
     		++$__gettext_pp_unavailable_dirs->{$fulldir} and next
     				unless -d $fulldir;
                         my $filename = File::Spec->catfile ($fulldir, 
                                                             "$domainname.mo");
     		my $domain = __load_catalog ($filename, $try);
     		next unless $domain;
     			
     		$domain->{locale_id} = $locale_lookup{$try};
     		push @$domains, $domain;
     	}
     }
     $__gettext_pp_domain_cache->{$dir}
                               ->{$cache_key}
                               ->{$category_name}
                               ->{$domainname} = $domains;
 
     $domains = [] unless defined $domains;
     
     return $domains;
 }
 
 sub __load_catalog
 {
     my ($filename, $locale) = @_;
     
     return unless -f $filename && -r $filename;
     
     local $/;
     local *HANDLE;
     
     open HANDLE, "<$filename"
     	or return;
     binmode HANDLE;
     my $raw = <HANDLE>;
     close HANDLE;
     
     return if ! defined $raw || length $raw < 28;
     
     my $filesize = length $raw;
     
     my $domain = {};
     my $unpack = 'N';
     $domain->{potter} = unpack $unpack, substr $raw, 0, 4;
     
     if ($domain->{potter} == 0xde120495) {
     	$unpack = 'V';
     } elsif ($domain->{potter} != 0x950412de) {
     	return;
     }
     my $domain_unpack = $unpack x 6;
     
     my ($revision, $num_strings, $msgids_off, $msgstrs_off,
     	$hash_size, $hash_off) = 
     		unpack (($unpack x 6), substr $raw, 4, 24);
     
     return unless $revision == 0; 
     
     $domain->{revision} = $revision;
     $domain->{num_strings} = $num_strings;
     $domain->{msgids_off} = $msgids_off;
     $domain->{msgstrs_off} = $msgstrs_off;
     $domain->{hash_size} = $hash_size;
     $domain->{hash_off} = $hash_off;
     
     return if $msgids_off + 4 * $num_strings > $filesize;
     return if $msgstrs_off + 4 * $num_strings > $filesize;
     
     my @orig_tab = unpack (($unpack x (2 * $num_strings)), 
     					   substr $raw, $msgids_off, 8 * $num_strings);
     my @trans_tab = unpack (($unpack x (2 * $num_strings)), 
     						substr $raw, $msgstrs_off, 8 * $num_strings);
     
     my $messages = {};
     
     for (my $count = 0; $count < 2 * $num_strings; $count += 2) {
     	my $orig_length = $orig_tab[$count];
     	my $orig_offset = $orig_tab[$count + 1];
     	my $trans_length = $trans_tab[$count];
     	my $trans_offset = $trans_tab[$count + 1];
     	
     	return if $orig_offset + $orig_length > $filesize;
     	return if $trans_offset + $trans_length > $filesize;
     	
     	my @origs = split /\000/, substr $raw, $orig_offset, $orig_length;
     	my @trans = split /\000/, substr $raw, $trans_offset, $trans_length;
     	
     	my $msgid = $origs[0];
     	$msgid = '' unless defined $msgid && length $msgid;
     	my $msgstr = [ $origs[1], @trans ];
     	$messages->{$msgid} = $msgstr;
     }
     
     $domain->{messages} = $messages;
     
     my $po_header = {};
     my $null_entry = $messages->{''}->[1];
     if ($null_entry) {
     	my @lines = split /\n/, $null_entry;
     	foreach my $line (@lines) {
     		my ($key, $value) = split /:/, $line, 2;
     		$key =~ s/-/_/g;
     		$po_header->{lc $key} = $value;
     	}
     }
     $domain->{po_header} = $po_header;
     
     if (exists $domain->{po_header}->{content_type}) {
     	my $content_type = $domain->{po_header}->{content_type};
     	if ($content_type =~ s/.*=//) {
     		$domain->{po_header}->{charset} = $content_type;
     	}
     }
     
     my $code = $domain->{po_header}->{plural_forms} || '';
     
     my $s = '[ \t\r\n\013\014]';
 
     $code = $domain->{po_header}->{plural_forms} 
         = __untaint_plural_header $code;
 
     $domain->{plural_func} = __compile_plural_function $code;
 
     unless (defined $domain->{po_header}->{charset} 
             && length $domain->{po_header}->{charset} 
             && $locale =~ /^(?:[a-z][a-z])
                             (?:(?:_[A-Z][A-Z])?
                              (\.[-_A-Za-z0-9]+)?
                             )?
                             (?:\@[-_A-Za-z0-9]+)?$/x) {
         $domain->{po_header}->{charset} = $1;
     }
                                 
     if (defined $domain->{po_header}->{charset}) {
         $domain->{po_header}->{charset} = 
             Locale::Recode->resolveAlias ($domain->{po_header}->{charset});
     }
     
     return $domain;
 }
 
 sub __locale_category
 {
     my ($category, $category_name) = @_;
     
     local $@;
     my $value = eval {POSIX::setlocale ($category)};
     
     undef $value unless (defined $value && 
     					 length $value &&
     					 $value =~ /^[a-z][a-z]
     					 (?:_[A-Z][A-Z]
     					  (?:\.[-_A-Za-z0-9]+)?
     					  )?
     					 (?:\@[-_A-Za-z0-9]+)?$/x);
 
     unless ($value) {
     	$value = $ENV{LC_ALL};
     	$value = $ENV{$category_name} unless defined $value && length $value;
     	$value = $ENV{LANG} unless defined $value && length $value;
     	return 'C' unless defined $value && length $value;
     }
     
     return $value if $value ne 'C' && $value ne 'POSIX';
 }
 
 sub __get_codeset
 {
     my ($category, $category_name, $locale_id) = @_;
 
     local $@;
     unless (defined $has_nl_langinfo) {
     	eval {
     		require I18N::Langinfo;
     	};
     	$has_nl_langinfo = !$@;
     }
 
     if ($has_nl_langinfo) {
     	my $saved_locale = eval { POSIX::setlocale (LC_ALL) };
     	my $had_lc_all = exists $ENV{LC_ALL};
     	my $saved_lc_all = $ENV{LC_ALL} if $had_lc_all;
 
     	$ENV{LC_ALL} = $locale_id;
     	my $codeset;
     	my $lc_all = eval { POSIX::setlocale (LC_ALL, $locale_id); };
     	$codeset = I18N::Langinfo::langinfo (I18N::Langinfo::CODESET())
     		if defined $lc_all;
 
     	if ($saved_locale) {
     		eval { POSIX::setlocale (LC_ALL, $saved_locale); }
     	}
     	if ($had_lc_all) {
             $ENV{LC_ALL} = $saved_lc_all if $had_lc_all;
     	} else {
     	    delete $ENV{LC_ALL};
     	}
     	return $codeset;
     }
 
     return;
 }
     
 sub __untaint_plural_header {
     my ($code) = @_;
 
     my $s = '[ \t\r\n\013\014]';
 
     if ($code =~ m{^($s*
     				 nplurals$s*=$s*[0-9]+
     				 $s*;$s*
     				 plural$s*=$s*(?:$s|[-\?\|\&=!<>+*/\%:;a-zA-Z0-9_\(\)])+
     				 )}xms) {
     	return $1;
     }
 
     return '';    
 }
 
 sub __compile_plural_function {
     my ($code) = @_;
 
     my $plural_func;
     
     if (length $code) {
     	my $code = ' ' . $code . ' ';
     	$code =~ 
     		s/(?<=[^_a-zA-Z0-9])[_a-z][_A-Za-z0-9]*(?=[^_a-zA-Z0-9])/\$$&/gs;
     	
     	$code = "sub { my \$n = shift || 0; 
     			   my (\$plural, \$nplurals); 
     			   $code; 
     			   return (\$nplurals, \$plural ? \$plural : 0); }";
     	
     	$plural_func = eval $code;
     	undef $plural_func if $@;
     }
         
     $plural_func = eval "sub { (2, 1 != shift || 0) }" unless $plural_func;
 
     return $plural_func;    
 }
 
 1;
 
 __END__
 
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 tab-width: 4
 End:
 
### Locale/gettext_xs.pm ###
 #! /bin/false
 
 
 
 
 
 
 package Locale::gettext_xs;
 
 require DynaLoader;
 require Exporter;
 
 use vars qw (%EXPORT_TAGS @EXPORT_OK @ISA);
 
 %EXPORT_TAGS = (locale_h => [ qw (
 								  gettext
 								  dgettext
 								  dcgettext
 								  ngettext
 								  dngettext
 								  dcngettext
 								  pgettext
 								  dpgettext
 								  dcpgettext
 								  npgettext
 								  dnpgettext
 								  dcnpgettext
 								  textdomain
 								  bindtextdomain
 								  bind_textdomain_codeset
 								  )
 							  ],
 				libintl_h => [ qw (LC_CTYPE
 								   LC_NUMERIC
 								   LC_TIME
 								   LC_COLLATE
 								   LC_MONETARY
 								   LC_MESSAGES
 								   LC_ALL)
 							   ],
 				);
 
 @EXPORT_OK = qw (gettext
 				 dgettext
 				 dcgettext
 				 ngettext
 				 dngettext
 				 dcngettext
                  pgettext
                  dpgettext
                  dcpgettext
                  npgettext
                  dnpgettext
                  dcnpgettext
 				 textdomain
 				 bindtextdomain
 				 bind_textdomain_codeset
 				 nl_putenv
                  setlocale
 				 LC_CTYPE
 				 LC_NUMERIC
 				 LC_TIME
 				 LC_COLLATE
 				 LC_MONETARY
 				 LC_MESSAGES
 				 LC_ALL);
 @ISA = qw (Exporter DynaLoader);
 
 bootstrap Locale::gettext_xs;
 
 require File::Spec;
 
 sub pgettext ($$) {
 	my ($msgctxt, $msgid) = @_;
 
 	my $msg_ctxt_id = join("\004", $msgctxt, $msgid);
 	return Locale::gettext_xs::_pgettext_aux
 		("", $msg_ctxt_id, $msgid, Locale::gettext_xs::LC_MESSAGES());
 }
 sub dpgettext ($$$) {
 	my ($domain, $msgctxt, $msgid) = @_;
 
 	my $msg_ctxt_id = join("\004", $msgctxt, $msgid);
 	return Locale::gettext_xs::_pgettext_aux
 		($domain, $msg_ctxt_id, $msgid, Locale::gettext_xs::LC_MESSAGES());
 }
 sub dcpgettext ($$$$) {
 	my ($domain, $msgctxt, $msgid, $category) = @_;
 
 	my $msg_ctxt_id = join("\004", $msgctxt, $msgid);
 	return Locale::gettext_xs::_pgettext_aux
 		($domain, $msg_ctxt_id, $msgid, $category);
 }
 
 sub npgettext ($$$$) {
 	my ($msgctxt, $msgid1, $msgid2, $n) = @_;
 
 	my $msg_ctxt_id = join("\004", $msgctxt, $msgid1);
 	return Locale::gettext_xs::_npgettext_aux
 		("", $msg_ctxt_id, $msgid1, $msgid2, $n, Locale::gettext_xs::LC_MESSAGES());
 }
 sub dnpgettext ($$$$$) {
 	my ($domain, $msgctxt, $msgid1, $msgid2, $n) = @_;
 
 	my $msg_ctxt_id = join("\004", $msgctxt, $msgid1);
 	return Locale::gettext_xs::_npgettext_aux
 		($domain, $msg_ctxt_id, $msgid1, $msgid2, $n, Locale::gettext_xs::LC_MESSAGES());
 }
 sub dcnpgettext ($$$$$$) {
 	my ($domain, $msgctxt, $msgid1, $msgid2, $n, $category) = @_;
 
 	my $msg_ctxt_id = join("\004", $msgctxt, $msgid1);
 	return Locale::gettext_xs::_npgettext_aux
 		($domain, $msg_ctxt_id, $msgid1, $msgid2, $n, $category);
 }
 
 sub bindtextdomain ($;$) {
 	my ($domain, $directory) = @_;
 
 	if (defined $domain && length $domain && 
 		defined $directory && length $directory) {
 		return Locale::gettext_xs::_bindtextdomain 
 			($domain, File::Spec->catdir ($directory));
 	} else {
 		return &Locale::gettext_xs::_bindtextdomain;
 	}
 }
 
 sub textdomain (;$) {
 	my $domain = shift;
 
 	if (defined $domain) {
 		return Locale::gettext_xs::_textdomain ($domain);
 	} else {
 		return Locale::gettext_xs::_textdomain ("");
 	}
 }
 
 sub nl_putenv ($) {
     my ($envspec) = @_;
     
     return unless defined $envspec;
     return unless length $envspec;
     return if substr ($envspec, 0, 1) eq '=';
     
     my ($var, $value) = split /=/, $envspec, 2;
     
     if ($^O eq 'MSWin32') {
         $value = '' unless defined $value;
         return unless Locale::gettext_xs::_nl_putenv ("$var=$value") == 0;
         if (length $value) {
             $ENV{$var} = $value;
         } else {
             delete $ENV{$var};
         }
     } else {
         if (defined $value) {
             $ENV{$var} = $value;
         } else {
             delete $ENV{$var};
         }
     }
 
     return 1;
 }
 
 1;
 
 __END__
 
 Local Variables:
 mode: perl
 perl-indent-level: 4
 perl-continued-statement-offset: 4
 perl-continued-brace-offset: 0
 perl-brace-offset: -4
 perl-brace-imaginary-offset: 0
 perl-label-offset: -4
 tab-width: 4
 End:
 
### Log/Any.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any;
 
 our $VERSION = '1.032';
 
 use Log::Any::Manager;
 use Log::Any::Adapter::Util qw(
   require_dynamic
   detection_aliases
   detection_methods
   log_level_aliases
   logging_aliases
   logging_and_detection_methods
   logging_methods
 );
 
 our $OverrideDefaultAdapterClass;
 our $OverrideDefaultProxyClass;
 
 {
     my $manager = Log::Any::Manager->new();
     sub _manager { return $manager }
 }
 
 sub import {
     my $class  = shift;
     my $caller = caller();
 
     my @export_params = ( $caller, @_ );
     $class->_export_to_caller(@export_params);
 }
 
 sub _export_to_caller {
     my $class  = shift;
     my $caller = shift;
 
     my $saw_log_param;
     my @params;
     while ( my $param = shift @_ ) {
         if ( $param eq '$log' ) {
             $saw_log_param = 1;    
             next;                  
         }
         else {
             push @params, $param, shift @_;    
         }
     }
 
     unless ( @params % 2 == 0 ) {
         require Carp;
         Carp::croak("Argument list not balanced: @params");
     }
 
     if ($saw_log_param) {
         no strict 'refs';
         my $proxy = $class->get_logger( category => $caller, @params );
         my $varname = "$caller\::log";
         *$varname = \$proxy;
     }
 }
 
 sub get_logger {
     my ( $class, %params ) = @_;
     no warnings 'once';
 
     my $proxy_class = $class->_get_proxy_class( delete $params{proxy_class} );
     my $category =
       defined $params{category} ? delete $params{'category'} : caller;
 
     if ( my $default = delete $params{'default_adapter'} ) {
         $class->_manager->set_default( $category, $default );
     }
 
     my $adapter = $class->_manager->get_adapter( $category );
 
     require_dynamic($proxy_class);
     return $proxy_class->new(
         %params, adapter => $adapter, category => $category,
     );
 }
 
 sub _get_proxy_class {
     my ( $self, $proxy_name ) = @_;
     return $Log::Any::OverrideDefaultProxyClass
       if $Log::Any::OverrideDefaultProxyClass;
     return "Log::Any::Proxy" unless $proxy_name;
     my $proxy_class = (
           substr( $proxy_name, 0, 1 ) eq '+'
         ? substr( $proxy_name, 1 )
         : "Log::Any::Proxy::$proxy_name"
     );
     return $proxy_class;
 }
 
 sub set_adapter {
     my $class = shift;
     Log::Any->_manager->set(@_);
 }
 
 1;
 
 __END__
 
### Log/Any/Adapter.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Adapter;
 
 our $VERSION = '1.032';
 
 use Log::Any;
 
 sub import {
     my $pkg = shift;
     Log::Any->_manager->set(@_) if (@_);
 }
 
 sub set {
     my $pkg = shift;
     Log::Any->_manager->set(@_)
 }
 
 sub remove {
     my $pkg = shift;
     Log::Any->_manager->remove(@_)
 }
 
 1;
 
 __END__
 
### Log/Any/Adapter/Base.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Adapter::Base;
 
 our $VERSION = '1.032';
 
 use Log::Any::Adapter::Util qw/make_method dump_one_line/;
 
 sub new {
     my $class = shift;
     my $self  = {@_};
     bless $self, $class;
     $self->init(@_);
     return $self;
 }
 
 sub init { }
 
 for my $method ( Log::Any::Adapter::Util::logging_and_detection_methods() ) {
     no strict 'refs';
     *$method = sub {
         my $class = ref( $_[0] ) || $_[0];
         die "$class does not implement $method";
     };
 }
 
 sub delegate_method_to_slot {
     my ( $class, $slot, $method, $adapter_method ) = @_;
 
     make_method( $method,
         sub { my $self = shift; return $self->{$slot}->$adapter_method(@_) },
         $class );
 }
 
 1;
### Log/Any/Adapter/File.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Adapter::File;
 
 our $VERSION = '1.032';
 
 use Config;
 use Fcntl qw/:flock/;
 use IO::File;
 use Log::Any::Adapter::Util ();
 
 use base qw/Log::Any::Adapter::Base/;
 
 my $HAS_FLOCK = $Config{d_flock} || $Config{d_fcntl_can_lock} || $Config{d_lockf};
 
 my $trace_level = Log::Any::Adapter::Util::numeric_level('trace');
 sub new {
     my ( $class, $file, @args ) = @_;
     return $class->SUPER::new( file => $file, log_level => $trace_level, @args );
 }
 
 sub init {
     my $self = shift;
     if ( exists $self->{log_level} ) {
         $self->{log_level} = Log::Any::Adapter::Util::numeric_level( $self->{log_level} )
             unless $self->{log_level} =~ /^\d+$/;
     }
     else {
         $self->{log_level} = $trace_level;
     }
     my $file = $self->{file};
     open( $self->{fh}, ">>", $file )
       or die "cannot open '$file' for append: $!";
     $self->{fh}->autoflush(1);
 }
 
 foreach my $method ( Log::Any::Adapter::Util::logging_methods() ) {
     no strict 'refs';
     my $method_level = Log::Any::Adapter::Util::numeric_level( $method );
     *{$method} = sub {
         my ( $self, $text ) = @_;
         return if $method_level > $self->{log_level};
         my $msg = sprintf( "[%s] %s\n", scalar(localtime), $text );
         flock($self->{fh}, LOCK_EX) if $HAS_FLOCK;
         $self->{fh}->print($msg);
         flock($self->{fh}, LOCK_UN) if $HAS_FLOCK;
       }
 }
 
 foreach my $method ( Log::Any::Adapter::Util::detection_methods() ) {
     no strict 'refs';
     my $base = substr($method,3);
     my $method_level = Log::Any::Adapter::Util::numeric_level( $base );
     *{$method} = sub {
         return !!(  $method_level <= $_[0]->{log_level} );
     };
 }
 
 1;
 
 __END__
 
### Log/Any/Adapter/Log4perl.pm ###
 use strict;
 use warnings;
 
 package Log::Any::Adapter::Log4perl;
 
 use Log::Log4perl 1.32; 
 use Log::Any::Adapter::Util 1.03 qw(make_method);
 use base qw(Log::Any::Adapter::Base);
 
 our $VERSION = '0.08';
 
 Log::Log4perl->wrapper_register(__PACKAGE__);
 Log::Log4perl->wrapper_register("Log::Any::Proxy");
 
 sub init {
     my ($self) = @_;
 
     $self->{logger} = Log::Log4perl->get_logger( $self->{category} );
 }
 
 foreach my $method ( Log::Any->logging_and_detection_methods() ) {
     my $log4perl_method = $method;
 
     for ($log4perl_method) {
         s/notice/info/;
         s/warning/warn/;
         s/critical|alert|emergency/fatal/;
     }
 
     make_method(
         $method,
         sub {
             my $self = shift;
             return $self->{logger}->$log4perl_method(@_);
         }
     );
 }
 
 1;
 
 __END__
 
### Log/Any/Adapter/Null.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Adapter::Null;
 
 our $VERSION = '1.032';
 
 use base qw/Log::Any::Adapter::Base/;
 
 use Log::Any::Adapter::Util ();
 
 
 foreach my $method (Log::Any::Adapter::Util::logging_and_detection_methods()) {
     no strict 'refs';
     *{$method} = sub { return '' }; 
 }
 
 1;
 
 __END__
 
### Log/Any/Adapter/Screen.pm ###
 package Log::Any::Adapter::Screen;
 
 our $DATE = '2015-06-19'; 
 our $VERSION = '0.09'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Log::Any;
 use Log::Any::Adapter::Util qw(make_method);
 use base qw(Log::Any::Adapter::Base);
 use Term::ANSIColor;
 use Time::HiRes qw(time);
 
 my $Time0 = time();
 
 my @logging_methods = Log::Any->logging_methods;
 our %logging_levels;
 for my $i (0..@logging_methods-1) {
     $logging_levels{$logging_methods[$i]} = $i;
 }
 $logging_levels{warn} = $logging_levels{warning};
 
 sub _default_level {
     return $ENV{LOG_LEVEL}
         if $ENV{LOG_LEVEL} && $logging_levels{$ENV{LOG_LEVEL}};
     return 'trace' if $ENV{TRACE};
     return 'debug' if $ENV{DEBUG};
     return 'info'  if $ENV{VERBOSE};
     return 'error' if $ENV{QUIET};
     'warning';
 }
 
 sub init {
     my ($self) = @_;
     $self->{stderr}    //= 1;
     $self->{use_color} //= (-t STDOUT);
     $self->{colors}    //= {
         trace     => 'yellow',
         debug     => '',
         info      => 'green',
         notice    => 'green',
         warning   => 'bold blue',
         error     => 'magenta',
         critical  => 'red',
         alert     => 'red',
         emergency => 'red',
     };
     $self->{min_level} //= _default_level();
     $self->{formatter} //= sub {
         my ($self, $msg) = @_;
         my $env = $ENV{LOG_PREFIX} // '';
         if ($env eq 'elapsed') {
             my $time = time();
             $msg = sprintf("[%9.3fms] %s", ($time - $Time0)*1000, $msg);
         }
         $msg;
     };
     $self->{_fh} = $self->{stderr} ? \*STDERR : \*STDOUT;
 }
 
 sub hook_before_log {
     return;
 }
 
 sub hook_after_log {
     my ($self, $msg) = @_;
     print { $self->{_fh} } "\n" unless $msg =~ /\n\z/;
 }
 
 for my $method (Log::Any->logging_methods()) {
     make_method(
         $method,
         sub {
             my ($self, $msg) = @_;
 
             return if $logging_levels{$method} <
                 $logging_levels{$self->{min_level}};
 
             $self->hook_before_log($msg);
 
             if ($self->{formatter}) {
                 $msg = $self->{formatter}->($self, $msg);
             }
 
             if ($self->{use_color} && $self->{colors}{$method}) {
                 $msg = Term::ANSIColor::colored($msg, $self->{colors}{$method});
             }
 
             print { $self->{_fh} } $msg;
 
             $self->hook_after_log($msg);
         }
     );
 }
 
 for my $method (Log::Any->detection_methods()) {
     my $level = $method; $level =~ s/^is_//;
     make_method(
         $method,
         sub {
             my $self = shift;
             $logging_levels{$level} >= $logging_levels{$self->{min_level}};
         }
     );
 }
 
 1;
 
 __END__
 
### Log/Any/Adapter/Stderr.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Adapter::Stderr;
 
 our $VERSION = '1.032';
 
 use Log::Any::Adapter::Util ();
 
 use base qw/Log::Any::Adapter::Base/;
 
 my $trace_level = Log::Any::Adapter::Util::numeric_level('trace');
 
 sub init {
     my ($self) = @_;
     if ( exists $self->{log_level} ) {
         $self->{log_level} =
           Log::Any::Adapter::Util::numeric_level( $self->{log_level} )
           unless $self->{log_level} =~ /^\d+$/;
     }
     else {
         $self->{log_level} = $trace_level;
     }
 }
 
 foreach my $method ( Log::Any::Adapter::Util::logging_methods() ) {
     no strict 'refs';
     my $method_level = Log::Any::Adapter::Util::numeric_level($method);
     *{$method} = sub {
         my ( $self, $text ) = @_;
         return if $method_level > $self->{log_level};
         print STDERR "$text\n";
     };
 }
 
 foreach my $method ( Log::Any::Adapter::Util::detection_methods() ) {
     no strict 'refs';
     my $base = substr( $method, 3 );
     my $method_level = Log::Any::Adapter::Util::numeric_level($base);
     *{$method} = sub {
         return !!( $method_level <= $_[0]->{log_level} );
     };
 }
 
 1;
 
 __END__
 
### Log/Any/Adapter/Stdout.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Adapter::Stdout;
 
 our $VERSION = '1.032';
 
 use Log::Any::Adapter::Util ();
 
 use base qw/Log::Any::Adapter::Base/;
 
 my $trace_level = Log::Any::Adapter::Util::numeric_level('trace');
 
 sub init {
     my ($self) = @_;
     if ( exists $self->{log_level} ) {
         $self->{log_level} =
           Log::Any::Adapter::Util::numeric_level( $self->{log_level} )
           unless $self->{log_level} =~ /^\d+$/;
     }
     else {
         $self->{log_level} = $trace_level;
     }
 }
 
 foreach my $method ( Log::Any::Adapter::Util::logging_methods() ) {
     no strict 'refs';
     my $method_level = Log::Any::Adapter::Util::numeric_level($method);
     *{$method} = sub {
         my ( $self, $text ) = @_;
         return if $method_level > $self->{log_level};
         print STDOUT "$text\n";
     };
 }
 
 foreach my $method ( Log::Any::Adapter::Util::detection_methods() ) {
     no strict 'refs';
     my $base = substr( $method, 3 );
     my $method_level = Log::Any::Adapter::Util::numeric_level($base);
     *{$method} = sub {
         return !!( $method_level <= $_[0]->{log_level} );
     };
 }
 
 1;
 
 __END__
 
### Log/Any/Adapter/Test.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Adapter::Test;
 
 our $VERSION = '1.032';
 
 use Log::Any::Adapter::Util qw/dump_one_line/;
 use Test::Builder;
 
 use base qw/Log::Any::Adapter::Base/;
 
 my $tb = Test::Builder->new();
 my @msgs;
 
 
 sub new {
     my $class = shift;
     if ( defined $Log::Any::OverrideDefaultAdapterClass
         && $Log::Any::OverrideDefaultAdapterClass eq __PACKAGE__ )
     {
         my $category = pop @_;
         return $class->SUPER::new( category => $category );
     }
     else {
         return $class->SUPER::new(@_);
     }
 }
 
 foreach my $method ( Log::Any::Adapter::Util::detection_methods() ) {
     no strict 'refs';
     *{$method} = sub { 1 };
 }
 
 foreach my $method ( Log::Any::Adapter::Util::logging_methods() ) {
     no strict 'refs';
     *{$method} = sub {
         my ( $self, $msg ) = @_;
         push(
             @msgs,
             {
                 message  => $msg,
                 level    => $method,
                 category => $self->{category}
             }
         );
     };
 }
 
 
 sub msgs {
     my $self = shift;
 
     return \@msgs;
 }
 
 sub clear {
     my ($self) = @_;
 
     @msgs = ();
 }
 
 sub contains_ok {
     my ( $self, $regex, $test_name ) = @_;
 
     $test_name ||= "log contains '$regex'";
     my $found =
       _first_index( sub { $_->{message} =~ /$regex/ }, @{ $self->msgs } );
     if ( $found != -1 ) {
         splice( @{ $self->msgs }, $found, 1 );
         $tb->ok( 1, $test_name );
     }
     else {
         $tb->ok( 0, $test_name );
         $tb->diag( "could not find message matching $regex; log contains: "
               . $self->dump_one_line( $self->msgs ) );
     }
 }
 
 sub category_contains_ok {
     my ( $self, $category, $regex, $test_name ) = @_;
 
     $test_name ||= "log for $category contains '$regex'";
     my $found =
       _first_index(
         sub { $_->{category} eq $category && $_->{message} =~ /$regex/ },
         @{ $self->msgs } );
     if ( $found != -1 ) {
         splice( @{ $self->msgs }, $found, 1 );
         $tb->ok( 1, $test_name );
     }
     else {
         $tb->ok( 0, $test_name );
         $tb->diag(
             "could not find $category message matching $regex; log contains: "
               . $self->dump_one_line( $self->msgs ) );
     }
 }
 
 sub does_not_contain_ok {
     my ( $self, $regex, $test_name ) = @_;
 
     $test_name ||= "log does not contain '$regex'";
     my $found =
       _first_index( sub { $_->{message} =~ /$regex/ }, @{ $self->msgs } );
     if ( $found != -1 ) {
         $tb->ok( 0, $test_name );
         $tb->diag( "found message matching $regex: " . $self->msgs->[$found] );
     }
     else {
         $tb->ok( 1, $test_name );
     }
 }
 
 sub category_does_not_contain_ok {
     my ( $self, $category, $regex, $test_name ) = @_;
 
     $test_name ||= "log for $category contains '$regex'";
     my $found =
       _first_index(
         sub { $_->{category} eq $category && $_->{message} =~ /$regex/ },
         @{ $self->msgs } );
     if ( $found != -1 ) {
         $tb->ok( 0, $test_name );
         $tb->diag( "found $category message matching $regex: "
               . $self->msgs->[$found] );
     }
     else {
         $tb->ok( 1, $test_name );
     }
 }
 
 sub empty_ok {
     my ( $self, $test_name ) = @_;
 
     $test_name ||= "log is empty";
     if ( !@{ $self->msgs } ) {
         $tb->ok( 1, $test_name );
     }
     else {
         $tb->ok( 0, $test_name );
         $tb->diag( "log is not empty; contains "
               . $self->dump_one_line( $self->msgs ) );
         $self->clear();
     }
 }
 
 sub contains_only_ok {
     my ( $self, $regex, $test_name ) = @_;
 
     $test_name ||= "log contains only '$regex'";
     my $count = scalar( @{ $self->msgs } );
     if ( $count == 1 ) {
         local $Test::Builder::Level = $Test::Builder::Level + 1;
         $self->contains_ok( $regex, $test_name );
     }
     else {
         $tb->ok( 0, $test_name );
         $tb->diag( "log contains $count messages: "
               . $self->dump_one_line( $self->msgs ) );
     }
 }
 
 sub _first_index {
     my $f = shift;
     for my $i ( 0 .. $#_ ) {
         local *_ = \$_[$i];
         return $i if $f->();
     }
     return -1;
 }
 
 1;
### Log/Any/Adapter/Util.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Adapter::Util;
 
 our $VERSION = '1.032';
 
 use Data::Dumper;
 use base qw(Exporter);
 
 my %LOG_LEVELS;
 BEGIN {
     %LOG_LEVELS = (
         EMERGENCY => 0,
         ALERT     => 1,
         CRITICAL  => 2,
         ERROR     => 3,
         WARNING   => 4,
         NOTICE    => 5,
         INFO      => 6,
         DEBUG     => 7,
         TRACE     => 8,
     );
 }
 
 use constant \%LOG_LEVELS;
 
 our @EXPORT_OK = qw(
   cmp_deeply
   detection_aliases
   detection_methods
   dump_one_line
   log_level_aliases
   logging_aliases
   logging_and_detection_methods
   logging_methods
   make_method
   numeric_level
   read_file
   require_dynamic
 );
 
 push @EXPORT_OK, keys %LOG_LEVELS;
 
 our %EXPORT_TAGS = ( 'levels' => [ keys %LOG_LEVELS ] );
 
 my ( %LOG_LEVEL_ALIASES, @logging_methods, @logging_aliases, @detection_methods,
     @detection_aliases, @logging_and_detection_methods );
 
 BEGIN {
     %LOG_LEVEL_ALIASES = (
         inform => 'info',
         warn   => 'warning',
         err    => 'error',
         crit   => 'critical',
         fatal  => 'critical'
     );
     @logging_methods =
       qw(trace debug info notice warning error critical alert emergency);
     @logging_aliases               = keys(%LOG_LEVEL_ALIASES);
     @detection_methods             = map { "is_$_" } @logging_methods;
     @detection_aliases             = map { "is_$_" } @logging_aliases;
     @logging_and_detection_methods = ( @logging_methods, @detection_methods );
 }
 
 
 sub logging_methods               { @logging_methods }
 
 
 sub detection_methods             { @detection_methods }
 
 
 sub logging_and_detection_methods { @logging_and_detection_methods }
 
 
 sub log_level_aliases             { %LOG_LEVEL_ALIASES }
 
 
 sub logging_aliases               { @logging_aliases }
 
 
 sub detection_aliases             { @detection_aliases }
 
 
 sub numeric_level {
     my ($level) = @_;
     my $canonical =
       exists $LOG_LEVEL_ALIASES{$level} ? $LOG_LEVEL_ALIASES{$level} : $level;
     return $LOG_LEVELS{ uc($canonical) };
 }
 
 
 sub dump_one_line {
     my ($value) = @_;
 
     return Data::Dumper->new( [$value] )->Indent(0)->Sortkeys(1)->Quotekeys(0)
       ->Terse(1)->Dump();
 }
 
 
 sub make_method {
     my ( $method, $code, $pkg ) = @_;
 
     $pkg ||= caller();
     no strict 'refs';
     *{ $pkg . "::$method" } = $code;
 }
 
 
 sub require_dynamic {
     my ($class) = @_;
 
     return 1 if $class->can('new'); 
 
     unless ( defined( eval "require $class; 1" ) )
     {    
         die $@;
     }
 }
 
 
 sub read_file {
     my ($file) = @_;
 
     local $/ = undef;
     open( my $fh, '<', $file )
       or die "cannot open '$file': $!";
     my $contents = <$fh>;
     return $contents;
 }
 
 
 sub cmp_deeply {
     my ( $ref1, $ref2, $name ) = @_;
 
     my $tb = Test::Builder->new();
     $tb->is_eq( dump_one_line($ref1), dump_one_line($ref2), $name );
 }
 
 require Log::Any;
 
 1;
 
 
 
 __END__
 
### Log/Any/App.pm ###
 package Log::Any::App;
 
 our $DATE = '2015-10-06'; 
 our $VERSION = '0.51'; 
 
 use 5.008000;
 use strict;
 use warnings;
 
 use File::Path qw(make_path);
 use File::Spec;
 use Log::Any::IfLOG;
 use Log::Any::Adapter;
 
 
 use vars qw($dbg_ctx);
 
 our %PATTERN_STYLES = (
     plain             => '%m',
     plain_nl          => '%m%n',
     script_short      => '[%r] %m%n',
     script_long       => '[%d] %m%n',
     daemon            => '[pid %P] [%d] %m%n',
     syslog            => '[pid %p] %m',
 );
 for (keys %PATTERN_STYLES) {
     $PATTERN_STYLES{"cat_$_"} = "[cat %c]$PATTERN_STYLES{$_}";
     $PATTERN_STYLES{"loc_$_"} = "[loc %l]$PATTERN_STYLES{$_}";
 }
 
 my $init_args;
 our $init_called;
 my $is_daemon;
 
 sub _ifdef {
     my $def = pop @_;
     for (@_) {
         return $_ if defined($_);
     }
     $def;
 }
 
 sub _ifdefj {
     require JSON;
 
     my $def = pop @_;
     for (@_) {
         return JSON::decode_json($_) if defined($_);
     }
     $def;
 }
 
 sub init {
     return if $init_called++;
 
     $is_daemon = undef;
 
     my ($args, $caller) = @_;
     $caller ||= caller();
 
     my $spec = _parse_opts($args, $caller);
     if ($spec->{log} && $spec->{init}) {
         _init_log4perl($spec);
         if ($ENV{LOG_ENV}) {
            my $log_main = Log::Any->get_logger(category => 'main');
            $log_main->tracef("Environment variables: %s", \%ENV);
        }
     }
     $spec;
 }
 
 sub _gen_appender_config {
     my ($ospec, $apd_name, $filter) = @_;
 
     my $name = $ospec->{name};
     my $class;
     my $params = {};
     if ($name =~ /^dir/i) {
         $class = "Log::Dispatch::Dir";
         $params->{dirname}   = $ospec->{path};
         $params->{filename_pattern} = $ospec->{filename_pattern};
         $params->{max_size}  = $ospec->{max_size} if $ospec->{max_size};
         $params->{max_files} = $ospec->{histories}+1 if $ospec->{histories};
         $params->{max_age}   = $ospec->{max_age} if $ospec->{max_age};
     } elsif ($name =~ /^file/i) {
         $class = "Log::Dispatch::FileWriteRotate";
         my ($dir, $prefix) = $ospec->{path} =~ m!(.+)/(.+)!;
         $dir ||= "."; $prefix ||= $ospec->{path};
         $params->{dir}         = $dir;
         $params->{prefix}      = $prefix;
         $params->{suffix}      = $ospec->{suffix};
         $params->{size}        = $ospec->{max_size};
         $params->{period}      = $ospec->{period};
         $params->{histories}   = $ospec->{histories};
         $params->{buffer_size} = $ospec->{buffer_size};
     } elsif ($name =~ /^screen/i) {
         $class = "Log::Log4perl::Appender::" .
             ($ospec->{color} ? "ScreenColoredLevels" : "Screen");
         $params->{stderr}  = $ospec->{stderr} ? 1:0;
         $params->{"color.WARN"} = "bold blue"; 
     } elsif ($name =~ /^syslog/i) {
         $class = "Log::Dispatch::Syslog";
         $params->{mode}     = 'append';
         $params->{ident}    = $ospec->{ident};
         $params->{facility} = $ospec->{facility};
     } elsif ($name =~ /^unixsock/i) {
         $class = "Log::Log4perl::Appender::Socket::UNIX";
         $params->{Socket} = $ospec->{path};
     } elsif ($name =~ /^array/i) {
         $class = "Log::Dispatch::ArrayWithLimits";
         $params->{array}     = $ospec->{array};
         $params->{max_elems} = $ospec->{max_elems};
     } else {
         die "BUG: Unknown appender type: $name";
     }
 
     join(
         "",
         "log4perl.appender.$apd_name = $class\n",
         (map { "log4perl.appender.$apd_name.$_ = $params->{$_}\n" }
              grep {defined $params->{$_}} keys %$params),
         "log4perl.appender.$apd_name.layout = PatternLayout\n",
         "log4perl.appender.$apd_name.layout.ConversionPattern = $ospec->{pattern}\n",
         ($filter ? "log4perl.appender.$apd_name.Filter = $filter\n" : ""),
     );
 }
 
 sub _lit {
     require Data::Dump;
     Data::Dump::dump(shift);
 }
 
 sub _gen_l4p_config {
     my ($spec) = @_;
 
     my @otypes = qw(file dir screen syslog unixsock array);
 
     my @fccode;
     push @fccode, 'my %p = @_';
     push @fccode, 'my $str';
     for my $ospec (map { @{ $spec->{$_} } } @otypes) {
         if (defined $ospec->{filter_text}) {
             push @fccode, '$str = '._lit($ospec->{filter_text});
             push @fccode, 'return 0 if $p{name} eq '._lit($ospec->{name}).
                 ' && index($_, $str) == -1';
         }
         if (defined $ospec->{filter_no_text}) {
             push @fccode, '$str = '._lit($ospec->{filter_no_text});
             push @fccode, 'return 0 if $p{name} eq '._lit($ospec->{name}).
                 ' && index($_, $str) > -1';
         }
         if (defined $ospec->{filter_citext}) {
             push @fccode, '$str = '._lit($ospec->{filter_citext});
             push @fccode, 'return 0 if $p{name} eq '._lit($ospec->{name}).
                 ' && !/\Q$str/io';
         }
         if (defined $ospec->{filter_no_citext}) {
             push @fccode, '$str = '._lit($ospec->{filter_no_citext});
             push @fccode, 'return 0 if $p{name} eq '._lit($ospec->{name}).
                 ' && /\Q$str/io';
         }
         if (defined $ospec->{filter_re}) {
             push @fccode, '$str = '._lit($ospec->{filter_re});
             push @fccode, 'return 0 if $p{name} eq '._lit($ospec->{name}).
                 ' && $_ !~ ' . (ref($ospec->{filter_re}) eq 'Regexp' ? '$str' : 'qr/$str/o');
         }
         if (defined $ospec->{filter_no_re}) {
             push @fccode, '$str = '._lit($ospec->{filter_no_re});
             push @fccode, 'return 0 if $p{name} eq '._lit($ospec->{name}).
                 ' && $_ =~ ' . (ref($ospec->{filter_re}) eq 'Regexp' ? '$str' : 'qr/$str/o');
         }
     }
     push @fccode, "1";
     my $fccode = join "; ", @fccode;
 
     my $filters_str = join(
         "",
         "log4perl.filter.FilterCustom = sub { $fccode }\n",
         "\n",
         "log4perl.filter.FilterOFF0 = Log::Log4perl::Filter::LevelRange\n",
         "log4perl.filter.FilterOFF0.LevelMin = TRACE\n",
         "log4perl.filter.FilterOFF0.LevelMax = FATAL\n",
         "log4perl.filter.FilterOFF0.AcceptOnMatch = false\n",
         "\n",
         "log4perl.filter.FilterOFF = Log::Log4perl::Filter::Boolean\n",
         "log4perl.filter.FilterOFF.logic = FilterOFF0 && FilterCustom\n",
         map {join(
             "",
             "log4perl.filter.Filter${_}0 = Log::Log4perl::Filter::LevelRange\n",
             "log4perl.filter.Filter${_}0.LevelMin = $_\n",
             "log4perl.filter.Filter${_}0.LevelMax = FATAL\n",
             "log4perl.filter.Filter${_}0.AcceptOnMatch = true\n",
             "\n",
             "log4perl.filter.Filter$_ = Log::Log4perl::Filter::Boolean\n",
             "log4perl.filter.Filter$_.logic = Filter${_}0 && FilterCustom\n",
             "\n",
         )} qw(FATAL ERROR WARN INFO DEBUG), 
     );
 
     my %levels; 
     my %cats;   
     my %ospecs; 
 
     for my $ospec (map { @{ $spec->{$_} } } @otypes) {
         my $oname = $ospec->{name};
         $ospecs{$oname} = $ospec;
         $levels{$oname} = {};
         my %seen_cats;
         if ($ospec->{category_level}) {
             while (my ($cat0, $level) = each %{ $ospec->{category_level} }) {
                 my @cat = _extract_category($ospec, $cat0);
                 for my $cat (@cat) {
                     next if $seen_cats{$cat}++;
                     $cats{$cat}++;
                     $levels{$oname}{$cat} = $level;
                 }
             }
         }
         if ($spec->{category_level}) {
             while (my ($cat0, $level) = each %{ $spec->{category_level} }) {
                 my @cat = _extract_category($ospec, $cat0);
                 for my $cat (@cat) {
                     next if $seen_cats{$cat}++;
                     $cats{$cat}++;
                     $levels{$oname}{$cat} = $level;
                 }
             }
         }
         my @cat = _extract_category($ospec);
         for my $cat (@cat) {
             next if $seen_cats{$cat}++;
             $cats{$cat}++;
             $levels{$oname}{$cat} = $ospec->{level};
         }
     }
 
     my $find_olevel = sub {
         my ($oname, $cat) = @_;
         my $olevel = $levels{$oname}{''};
         my @c = split /\./, $cat;
         for (my $i=0; $i<@c; $i++) {
             my $c = join(".", @c[0..$i]);
             if ($levels{$oname}{$c}) {
                 $olevel = $levels{$oname}{$c};
             }
         }
         $olevel;
     };
 
     my %cat_configs; 
     my $add_str = '';
     my $apd_str = '';
     for my $cat0 (sort {$a cmp $b} keys %cats) {
         $add_str .= "log4perl.additivity.$cat0 = 0\n" unless $cat0 eq '';
         my @cats = ($cat0);
         while ($cat0 =~ s/\.[^.]+$//) { push @cats, $cat0 }
         for my $cat (@cats) {
             my $cat_level;
             for my $oname (keys %levels) {
                 my $olevel = $find_olevel->($oname, $cat);
                 next unless $olevel;
                 $cat_level = _ifdef($cat_level, $olevel);
                 $cat_level = _min_level($cat_level, $olevel);
             }
             $cat_configs{$cat} = [uc($cat_level)];
         }
     }
 
     my %generated_appenders; 
     for my $cat (keys %cat_configs) {
         my $cat_level = $cat_configs{$cat}[0];
         for my $oname (keys %levels) {
             my $ospec = $ospecs{$oname};
             my $olevel = $find_olevel->($oname, $cat);
             my $apd_name;
             my $filter;
             if ($olevel ne $cat_level &&
                     _min_level($olevel, $cat_level) eq $cat_level) {
                 $apd_name = $oname . "_" . uc($olevel);
                 $filter = "Filter".uc($olevel);
             } else {
                 $apd_name = $oname;
                 $filter = "FilterCustom";
             }
             unless ($generated_appenders{$apd_name}++) {
                 $apd_str .= _gen_appender_config($ospec, $apd_name, $filter).
                     "\n";
             }
             push @{ $cat_configs{$cat} }, $apd_name;
         }
     }
 
     my $cat_str = '';
     for my $cat (sort {$a cmp $b} keys %cat_configs) {
         my $l = $cat eq '' ? '' : ".$cat";
         $cat_str .= "log4perl.logger$l = ".join(", ", @{ $cat_configs{$cat} })."\n";
     }
 
     join(
         "",
         "# filters\n", $filters_str,
         "# categories\n", $cat_str, $add_str, "\n",
         "# appenders\n", $apd_str,
     );
 }
 
 sub _init_log4perl {
     require Log::Log4perl;
 
     my ($spec) = @_;
 
     for (@{ $spec->{dir} }) {
         my $dir = _dirname($_->{path});
         make_path($dir) if length($dir) && !(-d $dir);
     }
 
     for (@{ $spec->{file} }) {
         my $dir = _dirname($_->{path});
         make_path($dir) if length($dir) && !(-d $dir);
     }
 
     my $config_str = _gen_l4p_config($spec);
     if ($spec->{dump}) {
         require Data::Dump;
         print "Log::Any::App configuration:\n",
             Data::Dump::dump($spec);
         print "Log4perl configuration: <<EOC\n", $config_str, "EOC\n";
     }
 
     Log::Log4perl->init(\$config_str);
     Log::Any::Adapter->set('Log4perl');
 }
 
 sub _basename {
     my $path = shift;
     my ($vol, $dir, $file) = File::Spec->splitpath($path);
     $file;
 }
 
 sub _dirname {
     my $path = shift;
     my ($vol, $dir, $file) = File::Spec->splitpath($path);
     $dir;
 }
 
 
 sub _parse_args {
     my ($args, $caller) = @_;
     $args = _ifdef($args, []); 
 
     my $i = 0;
     while ($i < @$args) {
         my $arg = $args->[$i];
         do { $i+=2; next } if $arg =~ /^-(\w+)$/;
         if ($arg eq '$log') {
             _export_logger($caller);
         } else {
             die "Unknown arg '$arg', valid arg is '\$log' or -OPTS";
         }
         $i++;
     }
 }
 
 sub _parse_opts {
     require File::HomeDir;
 
     my ($args, $caller) = @_;
     $args = _ifdef($args, []); 
     _debug("parse_opts: args = [".join(", ", @$args)."]");
 
     my $i = 0;
     my %opts;
     while ($i < @$args) {
         my $arg = $args->[$i];
         do { $i++; next } unless $arg =~ /^-(\w+)$/;
         my $opt = $1;
         die "Missing argument for option $opt" unless $i++ < @$args-1;
         $arg = $args->[$i];
         $opts{$opt} = $arg;
         $i++;
     }
 
     my $spec = {};
 
     $spec->{log} = _ifdef($ENV{LOG}, 1);
     if (defined $opts{log}) {
         $spec->{log} = $opts{log};
         delete $opts{log};
     }
     goto END_PARSE_OPTS unless $spec->{log};
 
     $spec->{name} = _basename($0);
     if (defined $opts{name}) {
         $spec->{name} = $opts{name};
         delete $opts{name};
     }
 
     $spec->{level_flag_paths} = [File::HomeDir->my_home, "/etc"];
     if (defined $opts{level_flag_paths}) {
         $spec->{level_flag_paths} = $opts{level_flag_paths};
         delete $opts{level_flag_paths};
     }
 
     $spec->{level} = _set_level("", "", $spec);
     if (!$spec->{level} && defined($opts{level})) {
         $spec->{level} = _check_level($opts{level}, "-level");
         _debug("Set general level to $spec->{level} (from -level)");
     } elsif (!$spec->{level}) {
         $spec->{level} = "warn";
         _debug("Set general level to $spec->{level} (default)");
     }
     delete $opts{level};
 
     $spec->{category_alias} = _ifdefj($ENV{LOG_CATEGORY_ALIAS}, {});
     if (defined $opts{category_alias}) {
         die "category_alias must be a hashref"
             unless ref($opts{category_alias}) eq 'HASH';
         $spec->{category_alias} = $opts{category_alias};
         delete $opts{category_alias};
     }
 
     if (defined $opts{category_level}) {
         die "category_level must be a hashref"
             unless ref($opts{category_level}) eq 'HASH';
         $spec->{category_level} = {};
         for (keys %{ $opts{category_level} }) {
             $spec->{category_level}{$_} =
                 _check_level($opts{category_level}{$_}, "-category_level{$_}");
         }
         delete $opts{category_level};
     }
 
     $spec->{init} = 1;
     if (defined $opts{init}) {
         $spec->{init} = $opts{init};
         delete $opts{init};
     }
 
     $spec->{daemon} = 0;
     if (defined $opts{daemon}) {
         $spec->{daemon} = $opts{daemon};
         _debug("setting is_daemon=$opts{daemon} (from daemon option)");
         $is_daemon = $opts{daemon};
         delete $opts{daemon};
     }
 
     $spec->{dump} = $ENV{LOGANYAPP_DEBUG};
     if (defined $opts{dump}) {
         $spec->{dump} = 1;
         delete $opts{dump};
     }
 
     $spec->{filter_text} = $ENV{LOG_FILTER_TEXT};
     if (defined $opts{filter_text}) {
         $spec->{filter_text} = $opts{filter_text};
         delete $opts{filter_text};
     }
     $spec->{filter_no_text} = $ENV{LOG_FILTER_NO_TEXT};
     if (defined $opts{filter_no_text}) {
         $spec->{filter_no_text} = $opts{filter_no_text};
         delete $opts{filter_no_text};
     }
     $spec->{filter_citext} = $ENV{LOG_FILTER_CITEXT};
     if (defined $opts{filter_citext}) {
         $spec->{filter_citext} = $opts{filter_citext};
         delete $opts{filter_citext};
     }
     $spec->{filter_no_citext} = $ENV{LOG_FILTER_NO_CITEXT};
     if (defined $opts{filter_no_citext}) {
         $spec->{filter_no_citext} = $opts{filter_no_citext};
         delete $opts{filter_no_citext};
     }
     $spec->{filter_re} = $ENV{LOG_FILTER_RE};
     if (defined $opts{filter_re}) {
         $spec->{filter_re} = $opts{filter_re};
         delete $opts{filter_re};
     }
     $spec->{filter_no_re} = $ENV{LOG_FILTER_NO_RE};
     if (defined $opts{filter_no_re}) {
         $spec->{filter_no_re} = $opts{filter_no_re};
         delete $opts{filter_no_re};
     }
 
     $spec->{file} = [];
     _parse_opt_file($spec, _ifdef($opts{file}, ($0 ne '-e' ? 1:0)));
     delete $opts{file};
 
     $spec->{dir} = [];
     _parse_opt_dir($spec, _ifdef($opts{dir}, 0));
     delete $opts{dir};
 
     $spec->{screen} = [];
     _parse_opt_screen($spec, _ifdef($opts{screen}, !_is_daemon()));
     delete $opts{screen};
 
     $spec->{syslog} = [];
     _parse_opt_syslog($spec, _ifdef($opts{syslog}, _is_daemon()));
     delete $opts{syslog};
 
     $spec->{unixsock} = [];
     _parse_opt_unixsock($spec, _ifdef($opts{unixsock}, 0));
     delete $opts{unixsock};
 
     $spec->{array} = [];
     _parse_opt_array($spec, _ifdef($opts{array}, 0));
     delete $opts{array};
 
     if (keys %opts) {
         die "Unknown option(s) ".join(", ", keys %opts)." Known opts are: ".
             "log, name, level, category_level, category_alias, dump, init, ".
                 "filter_{,no_}{text,citext,re}, file, dir, screen, syslog, ".
                     "unixsock, array";
     }
 
   END_PARSE_OPTS:
     $spec;
 }
 
 sub _is_daemon {
     if (defined $is_daemon) { return $is_daemon }
     if (defined $main::IS_DAEMON) {
         $is_daemon = $main::IS_DAEMON;
         _debug("Setting is_daemon=$main::IS_DAEMON (from \$main::IS_DAEMON)");
         return $main::IS_DAEMON;
     }
 
     for (
         "App/Daemon.pm",
         "Daemon/Easy.pm",
         "Daemon/Daemonize.pm",
         "Daemon/Generic.pm",
         "Daemonise.pm",
         "Daemon/Simple.pm",
         "HTTP/Daemon.pm",
         "IO/Socket/INET/Daemon.pm",
         "MooseX/Daemonize.pm",
         "Net/Daemon.pm",
         "Net/Server.pm",
         "Proc/Daemon.pm",
         "Proc/PID/File.pm",
         "Win32/Daemon/Simple.pm") {
         if ($INC{$_}) {
             _debug("setting is_daemon=1 (from existence of module $_)");
             $is_daemon = 1;
             return 1;
         }
     }
     _debug("setting is_daemon=0 (no indication that we are a daemon)");
     $is_daemon = 0;
     0;
 }
 
 sub _parse_opt_OUTPUT {
     my (%args) = @_;
     my $kind = $args{kind};
     my $default_sub = $args{default_sub};
     my $postprocess = $args{postprocess};
     my $spec = $args{spec};
     my $arg = $args{arg};
 
     return unless $arg;
 
     if (!ref($arg) || ref($arg) eq 'HASH') {
         my $name = uc($kind).(@{ $spec->{$kind} }+0);
         local $dbg_ctx = $name;
         push @{ $spec->{$kind} }, $default_sub->($spec);
         $spec->{$kind}[-1]{name} = $name;
         if (!ref($arg)) {
         } else {
             for my $k (keys %$arg) {
                 for ($spec->{$kind}[-1]) {
                     exists($_->{$k}) or die "Invalid $kind argument: $k, please".
                         " only specify one of: " . join(", ", sort keys %$_);
                     $_->{$k} = $k eq 'level' ?
                         _check_level($arg->{$k}, "-$kind") : $arg->{$k};
                     _debug("Set level of $kind to $_->{$k} (spec)")
                         if $k eq 'level';
                 }
             }
         }
         $spec->{$kind}[-1]{main_spec} = $spec;
         _set_pattern($spec->{$kind}[-1], $kind);
         $postprocess->(spec => $spec, ospec => $spec->{$kind}[-1])
             if $postprocess;
     } elsif (ref($arg) eq 'ARRAY') {
         for (@$arg) {
             _parse_opt_OUTPUT(%args, arg => $_);
         }
     } else {
         die "Invalid argument for -$kind, ".
             "must be a boolean or hashref or arrayref";
     }
 }
 
 sub _set_pattern_style {
     my ($x) = @_;
     ($ENV{LOG_SHOW_LOCATION} ? 'loc_':
          $ENV{LOG_SHOW_CATEGORY} ? 'cat_':'') . $x;
 }
 
 sub _default_file {
     require File::HomeDir;
 
     my ($spec) = @_;
     my $level = _set_level("file", "file", $spec);
     if (!$level) {
         $level = $spec->{level};
         _debug("Set level of file to $level (general level)");
     }
     return {
         level => $level,
         category_level => _ifdefj($ENV{FILE_LOG_CATEGORY_LEVEL},
                                   $ENV{LOG_CATEGORY_LEVEL},
                                   $spec->{category_level}),
         path => $> ? File::Spec->catfile(File::HomeDir->my_home, "$spec->{name}.log") :
             "/var/log/$spec->{name}.log", 
         max_size => undef,
         histories => undef,
         period => undef,
         buffer_size => undef,
         category => '',
         pattern_style => _set_pattern_style('daemon'),
         pattern => undef,
 
         filter_text      => _ifdef($ENV{FILE_LOG_FILTER_TEXT}, $spec->{filter_text}),
         filter_no_text   => _ifdef($ENV{FILE_LOG_FILTER_NO_TEXT}, $spec->{filter_no_text}),
         filter_citext    => _ifdef($ENV{FILE_LOG_FILTER_CITEXT}, $spec->{filter_citext}),
         filter_no_citext => _ifdef($ENV{FILE_LOG_FILTER_NO_CITEXT}, $spec->{filter_no_citext}),
         filter_re        => _ifdef($ENV{FILE_LOG_FILTER_RE}, $spec->{filter_re}),
         filter_no_re     => _ifdef($ENV{FILE_LOG_FILTER_NO_RE}, $spec->{filter_no_re}),
     };
 }
 
 sub _parse_opt_file {
     my ($spec, $arg) = @_;
 
     if (!ref($arg) && $arg && $arg !~ /^(1|yes|true)$/i) {
         $arg = {path => $arg};
     }
 
     _parse_opt_OUTPUT(
         kind => 'file', default_sub => \&_default_file,
         spec => $spec, arg => $arg,
         postprocess => sub {
             my (%args) = @_;
             my $spec  = $args{spec};
             my $ospec = $args{ospec};
             if ($ospec->{path} =~ m!/$!) {
                 my $p = $ospec->{path};
                 $p .= "$spec->{name}.log";
                 _debug("File path ends with /, assumed to be dir, ".
                            "final path becomes $p");
                 $ospec->{path} = $p;
             }
         },
     );
 }
 
 sub _default_dir {
     require File::HomeDir;
 
     my ($spec) = @_;
     my $level = _set_level("dir", "dir", $spec);
     if (!$level) {
         $level = $spec->{level};
         _debug("Set level of dir to $level (general level)");
     }
     return {
         level => $level,
         category_level => _ifdefj($ENV{DIR_LOG_CATEGORY_LEVEL},
                                    $ENV{LOG_CATEGORY_LEVEL},
                                    $spec->{category_level}),
         path => $> ? File::Spec->catfile(File::HomeDir->my_home, "log", $spec->{name}) :
             "/var/log/$spec->{name}", 
         max_size => undef,
         max_age => undef,
         histories => undef,
         category => '',
         pattern_style => _set_pattern_style('plain'),
         pattern => undef,
         filename_pattern => undef,
 
         filter_text      => _ifdef($ENV{DIR_LOG_FILTER_TEXT}, $spec->{filter_text}),
         filter_no_text   => _ifdef($ENV{DIR_LOG_FILTER_NO_TEXT}, $spec->{filter_no_text}),
         filter_citext    => _ifdef($ENV{DIR_LOG_FILTER_CITEXT}, $spec->{filter_citext}),
         filter_no_citext => _ifdef($ENV{DIR_LOG_FILTER_NO_CITEXT}, $spec->{filter_no_citext}),
         filter_re        => _ifdef($ENV{DIR_LOG_FILTER_RE}, $spec->{filter_re}),
         filter_no_re     => _ifdef($ENV{DIR_LOG_FILTER_NO_RE}, $spec->{filter_no_re}),
     };
 }
 
 sub _parse_opt_dir {
     my ($spec, $arg) = @_;
 
     if (!ref($arg) && $arg && $arg !~ /^(1|yes|true)$/i) {
         $arg = {path => $arg};
     }
 
     _parse_opt_OUTPUT(
         kind => 'dir', default_sub => \&_default_dir,
         spec => $spec, arg => $arg,
     );
 }
 
 sub _default_screen {
     my ($spec) = @_;
     my $level = _set_level("screen", "screen", $spec);
     if (!$level) {
         $level = $spec->{level};
         _debug("Set level of screen to $level (general level)");
     }
     return {
         color => _ifdef($ENV{COLOR}, (-t STDOUT)),
         stderr => 1,
         level => $level,
         category_level => _ifdefj($ENV{SCREEN_LOG_CATEGORY_LEVEL},
                                    $ENV{LOG_CATEGORY_LEVEL},
                                    $spec->{category_level}),
         category => '',
         pattern_style => _set_pattern_style(
             $ENV{LOG_ELAPSED_TIME_IN_SCREEN} ? 'script_short' : 'plain_nl'),
         pattern => undef,
 
         filter_text      => _ifdef($ENV{SCREEN_LOG_FILTER_TEXT}, $spec->{filter_text}),
         filter_no_text   => _ifdef($ENV{SCREEN_FILTER_NO_TEXT}, $spec->{filter_no_text}),
         filter_citext    => _ifdef($ENV{SCREEN_FILTER_CITEXT}, $spec->{filter_citext}),
         filter_no_citext => _ifdef($ENV{SCREEN_FILTER_NO_CITEXT}, $spec->{filter_no_citext}),
         filter_re        => _ifdef($ENV{SCREEN_FILTER_RE}, $spec->{filter_re}),
         filter_no_re     => _ifdef($ENV{SCREEN_FILTER_NO_RE}, $spec->{filter_no_re}),
     };
 }
 
 sub _parse_opt_screen {
     my ($spec, $arg) = @_;
     _parse_opt_OUTPUT(
         kind => 'screen', default_sub => \&_default_screen,
         spec => $spec, arg => $arg,
     );
 }
 
 sub _default_syslog {
     my ($spec) = @_;
     my $level = _set_level("syslog", "syslog", $spec);
     if (!$level) {
         $level = $spec->{level};
         _debug("Set level of syslog to $level (general level)");
     }
     return {
         level => $level,
         category_level => _ifdefj($ENV{SYSLOG_LOG_CATEGORY_LEVEL},
                                    $ENV{LOG_CATEGORY_LEVEL},
                                    $spec->{category_level}),
         ident => $spec->{name},
         facility => 'daemon',
         pattern_style => _set_pattern_style('syslog'),
         pattern => undef,
         category => '',
 
         filter_text      => _ifdef($ENV{SYSLOG_LOG_FILTER_TEXT}, $spec->{filter_text}),
         filter_no_text   => _ifdef($ENV{SYSLOG_FILTER_NO_TEXT}, $spec->{filter_no_text}),
         filter_citext    => _ifdef($ENV{SYSLOG_FILTER_CITEXT}, $spec->{filter_citext}),
         filter_no_citext => _ifdef($ENV{SYSLOG_FILTER_NO_CITEXT}, $spec->{filter_no_citext}),
         filter_re        => _ifdef($ENV{SYSLOG_FILTER_RE}, $spec->{filter_re}),
         filter_no_re     => _ifdef($ENV{SYSLOG_FILTER_NO_RE}, $spec->{filter_no_re}),
     };
 }
 
 sub _parse_opt_syslog {
     my ($spec, $arg) = @_;
     _parse_opt_OUTPUT(
         kind => 'syslog', default_sub => \&_default_syslog,
         spec => $spec, arg => $arg,
     );
 }
 
 sub _default_unixsock {
     require File::HomeDir;
 
     my ($spec) = @_;
     my $level = _set_level("unixsock", "unixsock", $spec);
     if (!$level) {
         $level = $spec->{level};
         _debug("Set level of unixsock to $level (general level)");
     }
     return {
         level => $level,
         category_level => _ifdefj($ENV{UNIXSOCK_LOG_CATEGORY_LEVEL},
                                   $ENV{LOG_CATEGORY_LEVEL},
                                   $spec->{category_level}),
         path => $> ? File::Spec->catfile(File::HomeDir->my_home, "$spec->{name}-log.sock") :
             "/var/run/$spec->{name}-log.sock", 
         category => '',
         pattern_style => _set_pattern_style('daemon'),
         pattern => undef,
 
         filter_text      => _ifdef($ENV{UNIXSOCK_LOG_FILTER_TEXT}, $spec->{filter_text}),
         filter_no_text   => _ifdef($ENV{UNIXSOCK_LOG_FILTER_NO_TEXT}, $spec->{filter_no_text}),
         filter_citext    => _ifdef($ENV{UNIXSOCK_LOG_FILTER_CITEXT}, $spec->{filter_citext}),
         filter_no_citext => _ifdef($ENV{UNIXSOCK_LOG_FILTER_NO_CITEXT}, $spec->{filter_no_citext}),
         filter_re        => _ifdef($ENV{UNIXSOCK_LOG_FILTER_RE}, $spec->{filter_re}),
         filter_no_re     => _ifdef($ENV{UNIXSOCK_LOG_FILTER_NO_RE}, $spec->{filter_no_re}),
     };
 }
 
 sub _parse_opt_unixsock {
     my ($spec, $arg) = @_;
 
     if (!ref($arg) && $arg && $arg !~ /^(1|yes|true)$/i) {
         $arg = {path => $arg};
     }
 
     _parse_opt_OUTPUT(
         kind => 'unixsock', default_sub => \&_default_unixsock,
         spec => $spec, arg => $arg,
         postprocess => sub {
             my (%args) = @_;
             my $spec  = $args{spec};
             my $ospec = $args{ospec};
             if ($ospec->{path} =~ m!/$!) {
                 my $p = $ospec->{path};
                 $p .= "$spec->{name}-log.sock";
                 _debug("Unix socket path ends with /, assumed to be dir, ".
                            "final path becomes $p");
                 $ospec->{path} = $p;
             }
 
         },
     );
 }
 
 sub _default_array {
     my ($spec) = @_;
     my $level = _set_level("array", "array", $spec);
     if (!$level) {
         $level = $spec->{level};
         _debug("Set level of array to $level (general level)");
     }
     return {
         level => $level,
         category_level => _ifdefj($ENV{ARRAY_LOG_CATEGORY_LEVEL},
                                   $ENV{LOG_CATEGORY_LEVEL},
                                   $spec->{category_level}),
         array => [],
         max_elems => undef,
         category => '',
         pattern_style => _set_pattern_style('script_long'),
         pattern => undef,
 
         filter_text      => _ifdef($ENV{ARRAY_LOG_FILTER_TEXT}, $spec->{filter_text}),
         filter_no_text   => _ifdef($ENV{ARRAY_LOG_FILTER_NO_TEXT}, $spec->{filter_no_text}),
         filter_citext    => _ifdef($ENV{ARRAY_LOG_FILTER_CITEXT}, $spec->{filter_citext}),
         filter_no_citext => _ifdef($ENV{ARRAY_LOG_FILTER_NO_CITEXT}, $spec->{filter_no_citext}),
         filter_re        => _ifdef($ENV{ARRAY_LOG_FILTER_RE}, $spec->{filter_re}),
         filter_no_re     => _ifdef($ENV{ARRAY_LOG_FILTER_NO_RE}, $spec->{filter_no_re}),
     };
 }
 
 sub _parse_opt_array {
     my ($spec, $arg) = @_;
 
     _parse_opt_OUTPUT(
         kind => 'array', default_sub => \&_default_array,
         spec => $spec, arg => $arg,
     );
 }
 
 sub _set_pattern {
     my ($s, $name) = @_;
     _debug("Setting $name pattern ...");
     unless (defined($s->{pattern})) {
         die "BUG: neither pattern nor pattern_style is defined ($name)"
             unless defined($s->{pattern_style});
         die "Unknown pattern style for $name `$s->{pattern_style}`, ".
             "use one of: ".join(", ", keys %PATTERN_STYLES)
             unless defined($PATTERN_STYLES{ $s->{pattern_style} });
         $s->{pattern} = $PATTERN_STYLES{ $s->{pattern_style} };
         _debug("Set $name pattern to `$s->{pattern}` ".
                    "(from style `$s->{pattern_style}`)");
     }
 }
 
 sub _extract_category {
     my ($ospec, $c) = @_;
     my $c0 = _ifdef($c, $ospec->{category});
     my @res;
     if (ref($c0) eq 'ARRAY') { @res = @$c0 } else { @res = ($c0) }
     for (my $i=0; $i<@res; $i++) {
         my $c1 = $res[$i];
         my $a = $ospec->{main_spec}{category_alias}{$c1};
         next unless defined($a);
         if (ref($a) eq 'ARRAY') {
             splice @res, $i, 1, @$a;
             $i += (@$a-1);
         } else {
             $res[$i] = $a;
         }
     }
     for (@res) {
         s/::/./g;
     }
     @res;
 }
 
 sub _cat2apd {
     my $cat = shift;
     $cat =~ s/[^A-Za-z0-9_]+/_/g;
     $cat;
 }
 
 sub _check_level {
     my ($level, $from) = @_;
     $level =~ /^(off|fatal|error|warn|info|debug|trace)$/i
         or die "Unknown level (from $from): $level";
     lc($1);
 }
 
 sub _set_level {
     my ($prefix, $which, $spec) = @_;
     my $p_ = $prefix ? "${prefix}_" : "";
     my $P_ = $prefix ? uc("${prefix}_") : "";
     my $F_ = $prefix ? ucfirst("${prefix}_") : "";
     my $pd = $prefix ? "${prefix}-" : "";
     my $pr = $prefix ? qr/$prefix(_|-)/ : qr//;
     my ($level, $from);
 
     my @label2level =([trace=>"trace"], [debug=>"debug"],
                       [verbose=>"info"], [quiet=>"error"]);
 
     _debug("Setting ", ($which ? "level of $which" : "general level"), " ...");
   SET:
     {
         if ($INC{"App/Options.pm"}) {
             my $key;
             for (qw/log_level loglevel/) {
                 $key = $p_ . $_;
                 _debug("Checking \$App::options{$key}: ", _ifdef($App::options{$key}, "(undef)"));
                 if ($App::options{$key}) {
                     $level = _check_level($App::options{$key}, "\$App::options{$key}");
                     $from = "\$App::options{$key}";
                     last SET;
                 }
             }
             for (@label2level) {
                 $key = $p_ . $_->[0];
                 _debug("Checking \$App::options{$key}: ", _ifdef($App::options{$key}, "(undef)"));
                 if ($App::options{$key}) {
                     $level = $_->[1];
                     $from = "\$App::options{$key}";
                     last SET;
                 }
             }
         }
 
         my $i = 0;
         _debug("Checking \@ARGV ...");
         while ($i < @ARGV) {
             my $arg = $ARGV[$i];
             $from = "cmdline arg $arg";
             if ($arg =~ /^--${pr}log[_-]?level=(.+)/) {
                 _debug("\$ARGV[$i] looks like an option to specify level: $arg");
                 $level = _check_level($1, "ARGV $arg");
                 last SET;
             }
             if ($arg =~ /^--${pr}log[_-]?level$/ and $i < @ARGV-1) {
                 _debug("\$ARGV[$i] and \$ARGV[${\($i+1)}] looks like an option to specify level: $arg ", $ARGV[$i+1]);
                 $level = _check_level($ARGV[$i+1], "ARGV $arg ".$ARGV[$i+1]);
                 last SET;
             }
             for (@label2level) {
                 if ($arg =~ /^--${pr}$_->[0](=(1|yes|true))?$/i) {
                     _debug("\$ARGV[$i] looks like an option to specify level: $arg");
                     $level = $_->[1];
                     last SET;
                 }
             }
             $i++;
         }
 
         for (qw/LOG_LEVEL LOGLEVEL/) {
             my $key = $P_ . $_;
             _debug("Checking environment variable $key: ", _ifdef($ENV{$key}, "(undef)"));
             if ($ENV{$key}) {
                 $level = _check_level($ENV{$key}, "ENV $key");
                 $from = "\$ENV{$key}";
                 last SET;
             }
         }
         for (@label2level) {
             my $key = $P_ . uc($_->[0]);
             _debug("Checking environment variable $key: ", _ifdef($ENV{$key}, "(undef)"));
             if ($ENV{$key}) {
                 $level = $_->[1];
                 $from = "\$ENV{$key}";
                 last SET;
             }
         }
 
         for my $dir (@{$spec->{level_flag_paths}}) {
             for (@label2level) {
                 my $filename = "$dir/$spec->{name}." . $P_ . "log_level";
                 my $exists = -f $filename;
                 my $content;
                 if ($exists) {
                     open my($f), $filename;
                     $content = <$f>;
                     chomp($content) if defined($content);
                     close $f;
                 }
                 _debug("Checking level flag file content $filename: ",
                        (defined($content) ? $content : "(undef)"));
                 if (defined $content) {
                     $level = _check_level($content,
                                           "level flag file $filename");
                     $from = $filename;
                     last SET;
                 }
 
                 $filename = "$dir/$spec->{name}." . $P_ . uc($_->[0]);
                 $exists = -e $filename;
                 _debug("Checking level flag file $filename: ",
                        ($exists ? "EXISTS" : 0));
                 if ($exists) {
                     $level = $_->[1];
                     $from = $filename;
                     last SET;
                 }
             }
         }
 
         no strict 'refs';
         for ("${F_}Log_Level", "${P_}LOG_LEVEL", "${p_}log_level",
              "${F_}LogLevel",  "${P_}LOGLEVEL",  "${p_}loglevel") {
             my $varname = "main::$_";
             _debug("Checking variable \$$varname: ", _ifdef($$varname, "(undef)"));
             if ($$varname) {
                 $from = "\$$varname";
                 $level = _check_level($$varname, "\$$varname");
                 last SET;
             }
         }
         for (@label2level) {
             for my $varname (
                 "main::$F_" . ucfirst($_->[0]),
                 "main::$P_" . uc($_->[0])) {
                 _debug("Checking variable \$$varname: ", _ifdef($$varname, "(undef)"));
                 if ($$varname) {
                     $from = "\$$varname";
                     $level = $_->[1];
                     last SET;
                 }
             }
         }
     }
 
     _debug("Set ", ($which ? "level of $which" : "general level"), " to $level (from $from)") if $level;
     return $level;
 }
 
 sub _min_level {
     my ($l1, $l2) = @_;
     my %vals = (OFF=>99,
                 FATAL=>6, ERROR=>5, WARN=>4, INFO=>3, DEBUG=>2, TRACE=>1);
     $vals{uc($l1)} > $vals{uc($l2)} ? $l2 : $l1;
 }
 
 sub _export_logger {
     my ($caller) = @_;
     my $log_for_caller = Log::Any->get_logger(category => $caller);
     my $varname = "$caller\::log";
     no strict 'refs';
     *$varname = \$log_for_caller;
 }
 
 sub _debug {
     return unless $ENV{LOGANYAPP_DEBUG};
     print $dbg_ctx, ": " if $dbg_ctx;
     print @_, "\n";
 }
 
 sub import {
     my ($self, @args) = @_;
     my $caller = caller();
     _parse_args(\@args, $caller);
     $init_args = \@args;
 }
 
 {
     no warnings;
     INIT {
         my $caller = caller();
         init($init_args, $caller);
     }
 }
 
 1;
 
 __END__
 
### Log/Any/IfLOG.pm ###
 package Log::Any::IfLOG;
 
 our $DATE = '2015-08-17'; 
 our $VERSION = '0.07'; 
 
 our $DEBUG;
 our $ENABLE_LOG;
 
 my $log_singleton;
 sub __log_singleton {
     if (!$log_singleton) { $log_singleton = Object::Dumb->new }
     $log_singleton;
 }
 
 sub __log_enabled {
     if (defined $ENABLE_LOG) {
         return $ENABLE_LOG;
     } elsif ($INC{'Log/Any.pm'}) {
         return 1;
     } else {
         return
             $ENV{LOG} || $ENV{TRACE} || $ENV{DEBUG} ||
             $ENV{VERBOSE} || $ENV{QUIET} || $ENV{LOG_LEVEL};
     }
 }
 
 sub import {
     my $self = shift;
 
     my $caller = caller();
     if (__log_enabled()) {
         require Log::Any;
         Log::Any->_export_to_caller($caller, @_);
     } else {
         my $saw_log_param = grep { $_ eq '$log' } @_;
         if ($saw_log_param) {
             __log_singleton(); 
             *{"$caller\::log"} = \$log_singleton;
         }
     }
 }
 
 sub get_logger {
     if (__log_enabled()) {
         require Log::Any;
         my $class = shift;
         if ($class eq 'Log::Any::IfLOG') {
             Log::Any->get_logger(@_);
         } else {
             Log::Any::get_logger($class, @_);
         }
     } else {
         return __log_singleton();
     }
 }
 
 package
     Object::Dumb;
 sub new { my $o = ""; bless \$o, shift }
 sub AUTOLOAD { 0 }
 
 1;
 
 __END__
 
### Log/Any/Manager.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Manager;
 
 our $VERSION = '1.032';
 
 sub new {
     my $class = shift;
     my $self  = {
         entries         => [],
         category_cache  => {},
         default_adapter => {},
     };
     bless $self, $class;
 
     return $self;
 }
 
 sub get_adapter {
     my ( $self, $category ) = @_;
 
     my $category_cache = $self->{category_cache};
     if ( !defined( $category_cache->{$category} ) ) {
         my $entry = $self->_choose_entry_for_category($category);
         my $adapter = $self->_new_adapter_for_entry( $entry, $category );
         $category_cache->{$category} = { entry => $entry, adapter => $adapter };
     }
     return $category_cache->{$category}->{adapter};
 }
 
 {
     no warnings 'once';
     *get_logger = \&get_adapter;    
 }
 
 sub _choose_entry_for_category {
     my ( $self, $category ) = @_;
 
     foreach my $entry ( @{ $self->{entries} } ) {
         if ( $category =~ $entry->{pattern} ) {
             return $entry;
         }
     }
     my $default = $self->{default_adapter}{$category}
         || [ $self->_get_adapter_class("Null"), [] ];
     my ($adapter_class, $adapter_params) = @$default;
     _require_dynamic($adapter_class);
     return {
         adapter_class  => $adapter_class,
         adapter_params => $adapter_params,
     };
 }
 
 sub _new_adapter_for_entry {
     my ( $self, $entry, $category ) = @_;
 
     return $entry->{adapter_class}
       ->new( @{ $entry->{adapter_params} }, category => $category );
 }
 
 sub set_default {
     my ( $self, $category, $adapter_name, @adapter_params ) = @_;
     my $adapter_class = $self->_get_adapter_class($adapter_name);
     $self->{default_adapter}{$category} = [$adapter_class, \@adapter_params];
 }
 
 sub set {
     my $self = shift;
     my $options;
     if ( ref( $_[0] ) eq 'HASH' ) {
         $options = shift(@_);
     }
     my ( $adapter_name, @adapter_params ) = @_;
 
     unless ( defined($adapter_name) && $adapter_name =~ /\S/ ) {
         require Carp;
         Carp::croak("expected adapter name");
     }
 
     my $pattern = $options->{category};
     if ( !defined($pattern) ) {
         $pattern = qr/.*/;
     }
     elsif ( !ref($pattern) ) {
         $pattern = qr/^\Q$pattern\E$/;
     }
 
     my $adapter_class = $self->_get_adapter_class($adapter_name);
     _require_dynamic($adapter_class);
 
     my $entry = $self->_new_entry( $pattern, $adapter_class, \@adapter_params );
     unshift( @{ $self->{entries} }, $entry );
 
     $self->_reselect_matching_adapters($pattern);
 
     if ( my $lex_ref = $options->{lexically} ) {
         $$lex_ref = Log::Any::Manager::_Guard->new(
             sub { $self->remove($entry) unless _in_global_destruction() } );
     }
 
     return $entry;
 }
 
 sub remove {
     my ( $self, $entry ) = @_;
 
     my $pattern = $entry->{pattern};
     $self->{entries} = [ grep { $_ ne $entry } @{ $self->{entries} } ];
     $self->_reselect_matching_adapters($pattern);
 }
 
 sub _new_entry {
     my ( $self, $pattern, $adapter_class, $adapter_params ) = @_;
 
     return {
         pattern        => $pattern,
         adapter_class  => $adapter_class,
         adapter_params => $adapter_params,
     };
 }
 
 sub _reselect_matching_adapters {
     my ( $self, $pattern ) = @_;
 
     return if _in_global_destruction();
 
     while ( my ( $category, $category_info ) =
         each( %{ $self->{category_cache} } ) )
     {
         my $new_entry = $self->_choose_entry_for_category($category);
         if ( $new_entry ne $category_info->{entry} ) {
             my $new_adapter =
               $self->_new_adapter_for_entry( $new_entry, $category );
             %{ $category_info->{adapter} } = %$new_adapter;
             bless( $category_info->{adapter}, ref($new_adapter) );
             $category_info->{entry} = $new_entry;
         }
     }
 }
 
 sub _get_adapter_class {
     my ( $self, $adapter_name ) = @_;
     return $Log::Any::OverrideDefaultAdapterClass if $Log::Any::OverrideDefaultAdapterClass;
     $adapter_name =~ s/^Log:://;    
     my $adapter_class = (
           substr( $adapter_name, 0, 1 ) eq '+'
         ? substr( $adapter_name, 1 )
         : "Log::Any::Adapter::$adapter_name"
     );
     return $adapter_class;
 }
 
 if ( defined ${^GLOBAL_PHASE} ) {
     eval 'sub _in_global_destruction () { ${^GLOBAL_PHASE} eq q[DESTRUCT] }; 1' 
       or die $@;
 }
 else {
     require B;
     my $started = !B::main_start()->isa(q[B::NULL]);
     unless ($started) {
         eval '0 && $started; CHECK { $started = 1 }; 1' 
           or die $@;
     }
     eval 
       '0 && $started; sub _in_global_destruction () { $started && B::main_start()->isa(q[B::NULL]) }; 1'
       or die $@;
 }
 
 sub _require_dynamic {
     my ($class) = @_;
 
     return 1 if $class->can('new'); 
 
     unless ( defined( eval "require $class; 1" ) )
     {    
         die $@;
     }
 }
 
 package    
   Log::Any::Manager::_Guard;
 
 sub new { bless $_[1], $_[0] }
 
 sub DESTROY { $_[0]->() }
 
 1;
### Log/Any/Proxy.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Proxy;
 
 our $VERSION = '1.032';
 
 use Log::Any::Adapter::Util ();
 
 sub _default_formatter {
     my ( $cat, $lvl, $format, @params ) = @_;
     my @new_params =
       map { !defined($_) ? '<undef>' : ref($_) ? _dump_one_line($_) : $_ }
       @params;
     return sprintf( $format, @new_params );
 }
 
 sub _dump_one_line {
     my ($value) = @_;
 
     return Data::Dumper->new( [$value] )->Indent(0)->Sortkeys(1)->Quotekeys(0)
       ->Terse(1)->Useqq(1)->Dump();
 }
 
 sub new {
     my $class = shift;
     my $self = { formatter => \&_default_formatter, @_ };
     unless ( $self->{adapter} ) {
         require Carp;
         Carp::croak("$class requires an 'adapter' parameter");
     }
     unless ( $self->{category} ) {
         require Carp;
         Carp::croak("$class requires an 'category' parameter")
     }
     bless $self, $class;
     $self->init(@_);
     return $self;
 }
 
 sub init { }
 
 for my $attr (qw/adapter filter formatter prefix/) {
     no strict 'refs';
     *{$attr} = sub { return $_[0]->{$attr} };
 }
 
 my %aliases = Log::Any::Adapter::Util::log_level_aliases();
 
 foreach my $name ( Log::Any::Adapter::Util::logging_methods(), keys(%aliases) )
 {
     my $realname    = $aliases{$name} || $name;
     my $namef       = $name . "f";
     my $is_name     = "is_$name";
     my $is_realname = "is_$realname";
     my $numeric     = Log::Any::Adapter::Util::numeric_level($realname);
     no strict 'refs';
     *{$is_name} = sub {
         my ($self) = @_;
         return $self->{adapter}->$is_realname;
     };
     *{$name} = sub {
         my ( $self, @parts ) = @_;
         my $message = join(" ", grep { defined($_) && length($_) } @parts );
         return unless length $message;
         $message = $self->{filter}->( $self->{category}, $numeric, $message )
           if defined $self->{filter};
         return unless defined $message and length $message;
         $message = "$self->{prefix}$message"
           if defined $self->{prefix} && length $self->{prefix};
         return $self->{adapter}->$realname($message);
     };
     *{$namef} = sub {
         my ( $self, @args ) = @_;
         return unless $self->{adapter}->$is_realname;
         my $message =
           $self->{formatter}->( $self->{category}, $numeric, @args );
         return unless defined $message and length $message;
         return $self->$name($message);
     };
 }
 
 1;
 
 
 
 __END__
 
### Log/Any/Proxy/Test.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Proxy::Test;
 
 our $VERSION = '1.032';
 
 use base qw/Log::Any::Proxy/;
 
 my @test_methods = qw(
   msgs
   clear
   contains_ok
   category_contains_ok
   does_not_contain_ok
   category_does_not_contain_ok
   empty_ok
   contains_only_ok
 );
 
 foreach my $name (@test_methods) {
     no strict 'refs';
     *{$name} = sub {
         my $self = shift;
         $self->{adapter}->$name(@_);
     };
 }
 
 1;
### Log/Any/Test.pm ###
 use 5.008001;
 use strict;
 use warnings;
 
 package Log::Any::Test;
 
 our $VERSION = '1.032';
 
 no warnings 'once';
 $Log::Any::OverrideDefaultAdapterClass = 'Log::Any::Adapter::Test';
 $Log::Any::OverrideDefaultProxyClass   = 'Log::Any::Proxy::Test';
 
 1;
 
 __END__
 
### Log/Dispatch.pm ###
 package Log::Dispatch;
 
 use 5.006;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use base qw( Log::Dispatch::Base );
 
 use Module::Runtime qw( use_package_optimistically );
 use Params::Validate 1.03 qw(validate_with ARRAYREF CODEREF);
 use Carp ();
 
 our %LEVELS;
 
 BEGIN {
     my %level_map = (
         (
             map { $_ => $_ }
                 qw(
                 debug
                 info
                 notice
                 warning
                 error
                 critical
                 alert
                 emergency
                 )
         ),
         warn  => 'warning',
         err   => 'error',
         crit  => 'critical',
         emerg => 'emergency',
     );
 
     foreach my $l ( keys %level_map ) {
         my $sub = sub {
             my $self = shift;
             $self->log(
                 level => $level_map{$l},
                 message => @_ > 1 ? "@_" : $_[0],
             );
         };
 
         $LEVELS{$l} = 1;
 
         no strict 'refs';
         *{$l} = $sub;
     }
 }
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     my %p = validate_with(
         params => \@_,
         spec   => {
             outputs => { type => ARRAYREF, optional => 1 },
             callbacks => { type => ARRAYREF | CODEREF, optional => 1 }
         },
         allow_extra => 1,    
     );
 
     my $self = bless {}, $class;
 
     my @cb = $self->_get_callbacks(%p);
     $self->{callbacks} = \@cb if @cb;
 
     if ( my $outputs = $p{outputs} ) {
         if ( ref $outputs->[1] eq 'HASH' ) {
 
             while ( my ( $class, $params ) = splice @$outputs, 0, 2 ) {
                 $self->_add_output( $class, %$params );
             }
         }
         else {
 
             foreach my $arr (@$outputs) {
                 die "expected arrayref, not '$arr'"
                     unless ref $arr eq 'ARRAY';
                 $self->_add_output(@$arr);
             }
         }
     }
 
     return $self;
 }
 
 sub clone {
     my $self = shift;
 
     my %clone = (
         callbacks => [ @{ $self->{callbacks} || [] } ],
         outputs   => { %{ $self->{outputs}   || {} } },
     );
 
     return bless \%clone, ref $self;
 }
 
 sub _add_output {
     my $self  = shift;
     my $class = shift;
 
     my $full_class
         = substr( $class, 0, 1 ) eq '+'
         ? substr( $class, 1 )
         : "Log::Dispatch::$class";
 
     use_package_optimistically($full_class);
 
     $self->add( $full_class->new(@_) );
 }
 
 sub add {
     my $self   = shift;
     my $object = shift;
 
     if ( exists $self->{outputs}{ $object->name } && $^W ) {
         Carp::carp(
             "Log::Dispatch::* object ", $object->name,
             " already exists."
         );
     }
 
     $self->{outputs}{ $object->name } = $object;
 }
 
 sub remove {
     my $self = shift;
     my $name = shift;
 
     return delete $self->{outputs}{$name};
 }
 
 sub outputs {
     my $self = shift;
 
     return values %{ $self->{outputs} };
 }
 
 sub callbacks {
     my $self = shift;
 
     return @{ $self->{callbacks} };
 }
 
 sub log {
     my $self = shift;
     my %p    = @_;
 
     return unless $self->would_log( $p{level} );
 
     $self->_log_to_outputs( $self->_prepare_message(%p) );
 }
 
 sub _prepare_message {
     my $self = shift;
     my %p    = @_;
 
     $p{message} = $p{message}->()
         if ref $p{message} eq 'CODE';
 
     $p{message} = $self->_apply_callbacks(%p)
         if $self->{callbacks};
 
     return %p;
 }
 
 sub _log_to_outputs {
     my $self = shift;
     my %p    = @_;
 
     foreach ( keys %{ $self->{outputs} } ) {
         $p{name} = $_;
         $self->_log_to(%p);
     }
 }
 
 sub log_and_die {
     my $self = shift;
 
     my %p = $self->_prepare_message(@_);
 
     $self->_log_to_outputs(%p) if $self->would_log( $p{level} );
 
     $self->_die_with_message(%p);
 }
 
 sub log_and_croak {
     my $self = shift;
 
     $self->log_and_die( @_, carp_level => 3 );
 }
 
 sub _die_with_message {
     my $self = shift;
     my %p    = @_;
 
     my $msg = $p{message};
 
     local $Carp::CarpLevel = ( $Carp::CarpLevel || 0 ) + $p{carp_level}
         if exists $p{carp_level};
 
     Carp::croak($msg);
 }
 
 sub log_to {
     my $self = shift;
     my %p    = @_;
 
     $p{message} = $self->_apply_callbacks(%p)
         if $self->{callbacks};
 
     $self->_log_to(%p);
 }
 
 sub _log_to {
     my $self = shift;
     my %p    = @_;
     my $name = $p{name};
 
     if ( exists $self->{outputs}{$name} ) {
         $self->{outputs}{$name}->log(@_);
     }
     elsif ($^W) {
         Carp::carp(
             "Log::Dispatch::* object named '$name' not in dispatcher\n");
     }
 }
 
 sub output {
     my $self = shift;
     my $name = shift;
 
     return unless exists $self->{outputs}{$name};
 
     return $self->{outputs}{$name};
 }
 
 sub level_is_valid {
     shift;
     my $level = shift
         or Carp::croak('Logging level was not provided');
 
     return $LEVELS{$level};
 }
 
 sub would_log {
     my $self  = shift;
     my $level = shift;
 
     return 0 unless $self->level_is_valid($level);
 
     foreach ( values %{ $self->{outputs} } ) {
         return 1 if $_->_should_log($level);
     }
 
     return 0;
 }
 
 sub is_debug     { $_[0]->would_log('debug') }
 sub is_info      { $_[0]->would_log('info') }
 sub is_notice    { $_[0]->would_log('notice') }
 sub is_warning   { $_[0]->would_log('warning') }
 sub is_warn      { $_[0]->would_log('warn') }
 sub is_error     { $_[0]->would_log('error') }
 sub is_err       { $_[0]->would_log('err') }
 sub is_critical  { $_[0]->would_log('critical') }
 sub is_crit      { $_[0]->would_log('crit') }
 sub is_alert     { $_[0]->would_log('alert') }
 sub is_emerg     { $_[0]->would_log('emerg') }
 sub is_emergency { $_[0]->would_log('emergency') }
 
 1;
 
 
 __END__
 
### Log/Dispatch/ApacheLog.pm ###
 package Log::Dispatch::ApacheLog;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Output;
 
 use base qw( Log::Dispatch::Output );
 
 use Params::Validate qw(validate);
 Params::Validate::validation_options( allow_extra => 1 );
 
 BEGIN {
     if ( $ENV{MOD_PERL} && $ENV{MOD_PERL} =~ /2\./ ) {
         require Apache2::Log;
     }
     else {
         require Apache::Log;
     }
 }
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     my %p = validate( @_, { apache => { can => 'log' } } );
 
     my $self = bless {}, $class;
 
     $self->_basic_init(%p);
     $self->{apache_log} = $p{apache}->log;
 
     return $self;
 }
 
 {
     my %methods = (
         emergency => 'emerg',
         critical  => 'crit',
         warning   => 'warn',
     );
 
     sub log_message {
         my $self = shift;
         my %p    = @_;
 
         my $level = $self->_level_as_name( $p{level} );
 
         my $method = $methods{$level} || $level;
 
         $self->{apache_log}->$method( $p{message} );
     }
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/ArrayWithLimits.pm ###
 package Log::Dispatch::ArrayWithLimits;
 
 use 5.010001;
 use warnings;
 use strict;
 
 use parent qw(Log::Dispatch::Output);
 
 our $DATE = '2015-01-03'; 
 our $VERSION = '0.04'; 
 
 sub new {
     my ($class, %args) = @_;
     my $self = {};
     $self->{array} = $args{array} // [];
     if (!ref($self->{array})) {
         no strict 'refs';
         say "$self->{array}";
         $self->{array} = \@{"$self->{array}"};
     }
     $self->{max_elems} = $args{max_elems} // undef;
     bless $self, $class;
     $self->_basic_init(%args);
     $self;
 }
 
 sub log_message {
     my $self = shift;
     my %args = @_;
 
     push @{$self->{array}}, $args{message};
 
     if (defined($self->{max_elems}) && @{$self->{array}} > $self->{max_elems}) {
         while (@{$self->{array}} > $self->{max_elems}) {
             shift @{$self->{array}};
         }
     }
 }
 
 1;
 
 __END__
 
### Log/Dispatch/Base.pm ###
 package Log::Dispatch::Base;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 sub _get_callbacks {
     shift;
     my %p = @_;
 
     return unless exists $p{callbacks};
 
     return @{ $p{callbacks} }
         if ref $p{callbacks} eq 'ARRAY';
 
     return $p{callbacks}
         if ref $p{callbacks} eq 'CODE';
 
     return;
 }
 
 sub _apply_callbacks {
     my $self = shift;
     my %p    = @_;
 
     my $msg = delete $p{message};
     foreach my $cb ( @{ $self->{callbacks} } ) {
         $msg = $cb->( message => $msg, %p );
     }
 
     return $msg;
 }
 
 sub add_callback {
     my $self  = shift;
     my $value = shift;
 
     Carp::carp("given value $value is not a valid callback")
         unless ref $value eq 'CODE';
 
     $self->{callbacks} ||= [];
     push @{ $self->{callbacks} }, $value;
 
     return;
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/Code.pm ###
 package Log::Dispatch::Code;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Output;
 
 use base qw( Log::Dispatch::Output );
 
 use Params::Validate qw(validate CODEREF);
 Params::Validate::validation_options( allow_extra => 1 );
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     my %p = validate( @_, { code => CODEREF } );
 
     my $self = bless {}, $class;
 
     $self->_basic_init(%p);
     $self->{code} = $p{code};
 
     return $self;
 }
 
 sub log_message {
     my $self = shift;
     my %p    = @_;
 
     delete $p{name};
 
     $self->{code}->(%p);
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/Dir.pm ###
 package Log::Dispatch::Dir;
 
 our $DATE = '2015-10-20'; 
 our $VERSION = '0.13'; 
 
 use 5.010001;
 use warnings;
 use strict;
 use Log::Dispatch::Output;
 use base qw(Log::Dispatch::Output);
 
 use File::Slurp::Tiny qw(write_file);
 use Params::Validate qw(validate SCALAR CODEREF);
 use POSIX;
 
 Params::Validate::validation_options( allow_extra => 1 );
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     my %p = @_;
 
     my $self = bless {}, $class;
 
     $self->_basic_init(%p);
     $self->_make_handle(%p);
 
     return $self;
 }
 
 sub _make_handle {
     my $self = shift;
 
     my %p = validate(
         @_,
         {
             dirname             => { type => SCALAR },
             permissions         => { type => SCALAR , optional => 1 },
             filename_pattern    => { type => SCALAR , optional => 1 },
             filename_sub        => { type => CODEREF, optional => 1 },
             max_size            => { type => SCALAR , optional => 1 },
             max_files           => { type => SCALAR , optional => 1 },
             max_age             => { type => SCALAR , optional => 1 },
             rotate_probability  => { type => SCALAR , optional => 1 },
         });
 
     $self->{dirname}            = $p{dirname};
     $self->{permissions}        = $p{permissions};
     $self->{filename_pattern}   = $p{filename_pattern} ||
         '%Y-%m-%d-%H%M%S.pid-%{pid}.%{ext}';
     $self->{filename_sub}       = $p{filename_sub};
     $self->{max_size}           = $p{max_size};
     $self->{max_files}          = $p{max_files};
     $self->{max_age}            = $p{max_age};
     $self->{rotate_probability} = ($p{rotate_probability}) || 0.25;
     $self->_open_dir();
 }
 
 sub _open_dir {
     my $self = shift;
 
     unless (-e $self->{dirname}) {
         my $perm = $self->{permissions} // 0755;
         mkdir($self->{dirname}, $perm)
             or die "Cannot create directory `$self->{dirname}: $!";
         $self->{chmodded} = 1;
     }
 
     unless (-d $self->{dirname}) {
         die "$self->{dirname} is not a directory";
     }
 
     if ($self->{permissions} && ! $self->{chmodded}) {
         chmod $self->{permissions}, $self->{dirname}
             or die "Cannot chmod $self->{dirname} to $self->{permissions}: $!";
         $self->{chmodded} = 1;
     }
 }
 
 my $default_ext = "log";
 my $libmagic;
 
 sub _resolve_pattern {
     my ($self, $p) = @_;
     my $pat = $self->{filename_pattern};
     my $now = time;
 
     my @vars = qw(Y y m d H M S z Z %);
     my $strftime = POSIX::strftime(join("|", map {"%$_"} @vars),
                                    localtime($now));
     my %vars;
     my $i = 0;
     for (split /\|/, $strftime) {
         $vars{ $vars[$i] } = $_;
         $i++;
     }
 
     push @vars, "{pid}";
     $vars{"{pid}"} = $$;
 
     push @vars, "{ext}";
     $vars{"{ext}"} = sub {
         my $p = shift;
         unless (defined $libmagic) {
             if (eval { require File::LibMagic; require Media::Type::Simple }) {
                 $libmagic = File::LibMagic->new;
             } else {
                 print "err = $@\n";
                 $libmagic = 0;
             }
         }
         return $default_ext unless $libmagic;
         my $type = $libmagic->checktype_contents($p->{message} // '');
         return $default_ext unless $type;
         $type =~ s/[; ].*//; 
         my $ext = Media::Type::Simple::ext_from_type($type);
         return $ext || $default_ext;
     };
 
     my $res = $pat;
     $res =~ s[%(\{\w+\}|\S)]
              [defined($vars{$1}) ?
                   ( ref($vars{$1}) eq 'CODE' ?
                         $vars{$1}->($p) : $vars{$1} ) :
                             die("Invalid filename_pattern `%$1'")]eg;
     $res;
 }
 
 sub log_message {
     my $self = shift;
     my %p = @_;
 
     my $filename0 = defined($self->{filename_sub}) ?
         $self->{filename_sub}->(%p) :
         $self->_resolve_pattern(\%p);
 
     my $filename = $filename0;
     my $i = 0;
     while (-e "$self->{dirname}/$filename") {
         $i++;
         $filename = "$filename0.$i";
     }
 
     write_file("$self->{dirname}/$filename", $p{message});
     $self->_rotate(\%p) if (rand() < $self->{rotate_probability});
 }
 
 sub _rotate {
     my ($self, $p) = @_;
 
     my $ms = $self->{max_size};
     my $mf = $self->{max_files};
     my $ma = $self->{max_age};
 
     return unless (defined($ms) || defined($mf) || defined($ma));
 
     my @entries;
     my $d = $self->{dirname};
     my $now = time;
     local *DH;
     opendir DH, $self->{dirname};
     while (my $e = readdir DH) {
         ($e) = $e =~ /(.*)/s; 
         next if $e eq '.' || $e eq '..';
         my @st = stat "$d/$e";
         push @entries, {name => $e, age => ($now-$st[10]), size => $st[7]};
     }
     closedir DH;
 
     @entries = sort {$a->{age} <=> $b->{age}} @entries;
 
     if (defined($mf) && @entries > $mf) {
         unlink "$d/$_->{name}" for (splice @entries, $mf);
     }
 
     if (defined($ma)) {
         my $i = 0;
         for (@entries) {
             if ($_->{age} > $ma) {
                 unlink "$d/$_->{name}" for (splice @entries, $i);
                 last;
             }
             $i++;
         }
     }
 
     if (defined($ms)) {
         my $i = 0;
         my $tot_size = 0;
         for (@entries) {
             $tot_size += $_->{size};
             if ($tot_size > $ms) {
                 unlink "$d/$_->{name}" for (splice @entries, $i);
                 last;
             }
             $i++;
         }
     }
 }
 
 1;
 
 __END__
 
### Log/Dispatch/Email.pm ###
 package Log::Dispatch::Email;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Output;
 
 use base qw( Log::Dispatch::Output );
 
 use Devel::GlobalDestruction qw( in_global_destruction );
 use Params::Validate qw(validate SCALAR ARRAYREF BOOLEAN);
 Params::Validate::validation_options( allow_extra => 1 );
 
 my ($program) = $0 =~ /(.+)/;
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     my %p = validate(
         @_, {
             subject => {
                 type    => SCALAR,
                 default => "$program: log email"
             },
             to => { type => SCALAR | ARRAYREF },
             from => {
                 type     => SCALAR,
                 optional => 1
             },
             buffered => {
                 type    => BOOLEAN,
                 default => 1
             },
         }
     );
 
     my $self = bless {}, $class;
 
     $self->_basic_init(%p);
 
     $self->{subject} = $p{subject} || "$0: log email";
     $self->{to} = ref $p{to} ? $p{to} : [ $p{to} ];
     $self->{from} = $p{from};
 
     $self->{buffered} = $p{buffered};
 
     $self->{buffer} = [] if $self->{buffered};
 
     return $self;
 }
 
 sub log_message {
     my $self = shift;
     my %p    = @_;
 
     if ( $self->{buffered} ) {
         push @{ $self->{buffer} }, $p{message};
     }
     else {
         $self->send_email(@_);
     }
 }
 
 sub send_email {
     my $self  = shift;
     my $class = ref $self;
 
     die "The send_email method must be overridden in the $class subclass";
 }
 
 sub flush {
     my $self = shift;
 
     if ( $self->{buffered} && @{ $self->{buffer} } ) {
         my $message = join '', @{ $self->{buffer} };
 
         $self->send_email( message => $message );
         $self->{buffer} = [];
     }
 }
 
 sub DESTROY {
     my $self = shift;
 
     if (   in_global_destruction()
         && $self->{buffered}
         && @{ $self->{buffer} } ) {
 
         my $name  = $self->name();
         my $class = ref $self;
         my $message
             = "Log messages for the $name output (a $class object) remain unsent but the program is terminating.\n";
         $message .= "The messages are:\n";
         $message .= "  $_\n" for @{ $self->{buffer} };
     }
     else {
         $self->flush();
     }
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/Email/MIMELite.pm ###
 package Log::Dispatch::Email::MIMELite;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Email;
 
 use base qw( Log::Dispatch::Email );
 
 use MIME::Lite;
 
 sub send_email {
     my $self = shift;
     my %p    = @_;
 
     my %mail = (
         To => ( join ',', @{ $self->{to} } ),
         Subject => $self->{subject},
         Type    => 'TEXT',
         Data    => $p{message},
     );
 
     $mail{From} = $self->{from} if defined $self->{from};
 
     local $?;
     unless ( MIME::Lite->new(%mail)->send ) {
         warn "Error sending mail with MIME::Lite";
     }
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/Email/MailSend.pm ###
 package Log::Dispatch::Email::MailSend;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Email;
 
 use base qw( Log::Dispatch::Email );
 
 use Mail::Send;
 
 sub send_email {
     my $self = shift;
     my %p    = @_;
 
     my $msg = Mail::Send->new;
 
     $msg->to( join ',', @{ $self->{to} } );
     $msg->subject( $self->{subject} );
 
     $msg->set( 'From', $self->{from} ) if $self->{from};
 
     local $?;
     eval {
         my $fh = $msg->open
             or die "Cannot open handle to mail program";
 
         $fh->print( $p{message} )
             or die "Cannot print message to mail program handle";
 
         $fh->close
             or die "Cannot close handle to mail program";
     };
 
     warn $@ if $@;
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/Email/MailSender.pm ###
 package Log::Dispatch::Email::MailSender;
 
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Email;
 
 use base qw( Log::Dispatch::Email );
 
 use Mail::Sender ();
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     my %p = @_;
 
     my $smtp = delete $p{smtp} || 'localhost';
     my $port = delete $p{port} || '25';
 
     my $authid       = delete $p{authid};
     my $authpwd      = delete $p{authpwd};
     my $auth         = delete $p{auth};
     my $tls_required = delete $p{tls_required};
     my $replyto      = delete $p{replyto};
     my $fake_from    = delete $p{fake_from};
 
     my $self = $class->SUPER::new(%p);
 
     $self->{smtp} = $smtp;
     $self->{port} = $port;
 
     $self->{authid}       = $authid;
     $self->{authpwd}      = $authpwd;
     $self->{auth}         = $auth;
     $self->{tls_required} = $tls_required;
 
     $self->{fake_from} = $fake_from;
     $self->{replyto}   = $replyto;
 
     return $self;
 }
 
 sub send_email {
     my $self = shift;
     my %p    = @_;
 
     local $?;
     eval {
         my $sender = Mail::Sender->new(
             {
                 from => $self->{from} || 'LogDispatch@foo.bar',
                 fake_from    => $self->{fake_from},
                 replyto      => $self->{replyto},
                 to           => ( join ',', @{ $self->{to} } ),
                 subject      => $self->{subject},
                 smtp         => $self->{smtp},
                 port         => $self->{port},
                 authid       => $self->{authid},
                 authpwd      => $self->{authpwd},
                 auth         => $self->{auth},
                 tls_required => $self->{tls_required},
 
             }
         );
 
         die "Error sending mail ($sender): $Mail::Sender::Error"
             unless ref $sender;
 
         ref $sender->MailMsg( { msg => $p{message} } )
             or die "Error sending mail: $Mail::Sender::Error";
     };
 
     warn $@ if $@;
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/Email/MailSendmail.pm ###
 package Log::Dispatch::Email::MailSendmail;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Email;
 
 use base qw( Log::Dispatch::Email );
 
 use Mail::Sendmail ();
 
 sub send_email {
     my $self = shift;
     my %p    = @_;
 
     my %mail = (
         To => ( join ',', @{ $self->{to} } ),
         Subject => $self->{subject},
         Message => $p{message},
 
         From => $self->{from} || 'LogDispatch@foo.bar',
     );
 
     local $?;
     unless ( Mail::Sendmail::sendmail(%mail) ) {
         warn "Error sending mail: $Mail::Sendmail::error";
     }
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/File.pm ###
 package Log::Dispatch::File;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Output;
 
 use base qw( Log::Dispatch::Output );
 
 use Params::Validate qw(validate SCALAR BOOLEAN);
 Params::Validate::validation_options( allow_extra => 1 );
 
 use Scalar::Util qw( openhandle );
 
 *O_APPEND = \&APPEND unless defined &O_APPEND;
 
 sub APPEND {0}
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     my %p = @_;
 
     my $self = bless {}, $class;
 
     $self->_basic_init(%p);
     $self->_make_handle;
 
     return $self;
 }
 
 sub _basic_init {
     my $self = shift;
 
     $self->SUPER::_basic_init(@_);
 
     my %p = validate(
         @_, {
             filename => { type => SCALAR },
             mode => {
                 type    => SCALAR,
                 default => '>'
             },
             binmode => {
                 type    => SCALAR,
                 default => undef
             },
             autoflush => {
                 type    => BOOLEAN,
                 default => 1
             },
             close_after_write => {
                 type    => BOOLEAN,
                 default => 0
             },
             permissions => {
                 type     => SCALAR,
                 optional => 1
             },
             syswrite => {
                 type    => BOOLEAN,
                 default => 0
             },
         }
     );
 
     $self->{filename}    = $p{filename};
     $self->{binmode}     = $p{binmode};
     $self->{autoflush}   = $p{autoflush};
     $self->{close}       = $p{close_after_write};
     $self->{permissions} = $p{permissions};
     $self->{syswrite}    = $p{syswrite};
 
     if ( $self->{close} ) {
         $self->{mode} = '>>';
     }
     elsif (
            exists $p{mode}
         && defined $p{mode}
         && (
             $p{mode} =~ /^(?:>>|append)$/
             || (   $p{mode} =~ /^\d+$/
                 && $p{mode} == O_APPEND() )
         )
         ) {
         $self->{mode} = '>>';
     }
     else {
         $self->{mode} = '>';
     }
 
 }
 
 sub _make_handle {
     my $self = shift;
 
     $self->_open_file() unless $self->{close};
 }
 
 sub _open_file {
     my $self = shift;
 
     open my $fh, $self->{mode}, $self->{filename}
         or die "Cannot write to '$self->{filename}': $!";
 
     if ( $self->{autoflush} ) {
         my $oldfh = select $fh;
         $| = 1;
         select $oldfh;
     }
 
     if ( $self->{permissions}
         && !$self->{chmodded} ) {
         my $current_mode = ( stat $self->{filename} )[2] & 07777;
         if ( $current_mode ne $self->{permissions} ) {
             chmod $self->{permissions}, $self->{filename}
                 or die
                 "Cannot chmod $self->{filename} to $self->{permissions}: $!";
         }
 
         $self->{chmodded} = 1;
     }
 
     if ( $self->{binmode} ) {
         binmode $fh, $self->{binmode};
     }
 
     $self->{fh} = $fh;
 }
 
 sub log_message {
     my $self = shift;
     my %p    = @_;
 
     if ( $self->{close} ) {
         $self->_open_file;
     }
 
     my $fh = $self->{fh};
 
     if ( $self->{syswrite} ) {
         defined syswrite( $fh, $p{message} )
             or die "Cannot write to '$self->{filename}': $!";
     }
     else {
         print $fh $p{message}
             or die "Cannot write to '$self->{filename}': $!";
     }
 
     if ( $self->{close} ) {
         close $fh
             or die "Cannot close '$self->{filename}': $!";
     }
 }
 
 sub DESTROY {
     my $self = shift;
 
     if ( $self->{fh} ) {
         my $fh = $self->{fh};
         close $fh if openhandle($fh);
     }
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/File/Locked.pm ###
 package Log::Dispatch::File::Locked;
 
 use strict;
 use warnings;
 
 use base qw( Log::Dispatch::File );
 
 our $VERSION = '2.51';
 
 use Fcntl qw(:DEFAULT :flock);
 
 sub _open_file {
     my $self = shift;
 
     $self->SUPER::_open_file();
 
     my $fh = $self->{fh};
 
     flock( $fh, LOCK_EX )
         or die "Cannot lock '$self->{filename}' for writing: $!";
 
     seek( $fh, 0, 2 )
         or die "Cannot seek to end of '$self->{filename}': $!";
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/FileWriteRotate.pm ###
 package Log::Dispatch::FileWriteRotate;
 
 our $DATE = '2015-01-26'; 
 our $VERSION = '0.03'; 
 
 use 5.010001;
 use warnings;
 use strict;
 
 use File::Write::Rotate;
 use Log::Dispatch::Output;
 use base qw(Log::Dispatch::Output);
 
 sub new {
     my $class = shift;
     my $self = bless {}, $class;
     my %args = @_;
     $self->_basic_init(%args);
     $self->_make_handle(%args);
 
     $self;
 }
 
 sub _make_handle {
     my $self = shift;
     my %args = @_;
 
     for (keys %args) {
         delete $args{$_} unless /\A(
                                      dir|prefix|suffix|period|size|histories|
                                      binmode|buffer_size|lock_mode|
                                      rotate_probability
                                  )\z/x;
     }
     $self->{_fwr} = File::Write::Rotate->new(%args);
 }
 
 sub log_message {
     my $self = shift;
     my %args = @_;
 
     $self->{_fwr}->write($args{message});
 }
 
 1;
 
 __END__
 
### Log/Dispatch/Handle.pm ###
 package Log::Dispatch::Handle;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Output;
 
 use base qw( Log::Dispatch::Output );
 
 use Params::Validate qw(validate SCALAR ARRAYREF BOOLEAN);
 Params::Validate::validation_options( allow_extra => 1 );
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     my %p = validate( @_, { handle => { can => 'print' } } );
 
     my $self = bless {}, $class;
 
     $self->_basic_init(%p);
     $self->{handle} = $p{handle};
 
     return $self;
 }
 
 sub log_message {
     my $self = shift;
     my %p    = @_;
 
     $self->{handle}->print( $p{message} )
         or die "Cannot write to handle: $!";
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/Null.pm ###
 package Log::Dispatch::Null;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Output;
 
 use base qw( Log::Dispatch::Output );
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     my $self = bless {}, $class;
 
     $self->_basic_init(@_);
 
     return $self;
 }
 
 sub log_message { }
 
 1;
 
 
 __END__
 
### Log/Dispatch/Output.pm ###
 package Log::Dispatch::Output;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch;
 
 use base qw( Log::Dispatch::Base );
 
 use Params::Validate qw(validate SCALAR ARRAYREF CODEREF BOOLEAN);
 Params::Validate::validation_options( allow_extra => 1 );
 
 use Carp ();
 
 my $level_names
     = [qw( debug info notice warning error critical alert emergency )];
 my $ln            = 0;
 my $level_numbers = {
     ( map { $_ => $ln++ } @{$level_names} ),
     warn  => 3,
     err   => 4,
     crit  => 5,
     emerg => 7
 };
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     die "The new method must be overridden in the $class subclass";
 }
 
 sub log {
     my $self = shift;
 
     my %p = validate(
         @_, {
             level   => { type => SCALAR },
             message => { type => SCALAR },
         }
     );
 
     return unless $self->_should_log( $p{level} );
 
     $p{message} = $self->_apply_callbacks(%p)
         if $self->{callbacks};
 
     $self->log_message(%p);
 }
 
 sub _basic_init {
     my $self = shift;
 
     my %p = validate(
         @_, {
             name      => { type => SCALAR, optional => 1 },
             min_level => { type => SCALAR, required => 1 },
             max_level => {
                 type     => SCALAR,
                 optional => 1
             },
             callbacks => {
                 type     => ARRAYREF | CODEREF,
                 optional => 1
             },
             newline => { type => BOOLEAN, optional => 1 },
         }
     );
 
     $self->{level_names}   = $level_names;
     $self->{level_numbers} = $level_numbers;
 
     $self->{name} = $p{name} || $self->_unique_name();
 
     $self->{min_level} = $self->_level_as_number( $p{min_level} );
     die "Invalid level specified for min_level"
         unless defined $self->{min_level};
 
     $self->{max_level} = (
         exists $p{max_level}
         ? $self->_level_as_number( $p{max_level} )
         : $#{ $self->{level_names} }
     );
 
     die "Invalid level specified for max_level"
         unless defined $self->{max_level};
 
     my @cb = $self->_get_callbacks(%p);
     $self->{callbacks} = \@cb if @cb;
 
     if ( $p{newline} ) {
         push @{ $self->{callbacks} }, \&_add_newline_callback;
     }
 }
 
 sub name {
     my $self = shift;
 
     return $self->{name};
 }
 
 sub min_level {
     my $self = shift;
 
     return $self->{level_names}[ $self->{min_level} ];
 }
 
 sub max_level {
     my $self = shift;
 
     return $self->{level_names}[ $self->{max_level} ];
 }
 
 sub accepted_levels {
     my $self = shift;
 
     return @{ $self->{level_names} }
         [ $self->{min_level} .. $self->{max_level} ];
 }
 
 sub _should_log {
     my $self = shift;
 
     my $msg_level = $self->_level_as_number(shift);
     return (   ( $msg_level >= $self->{min_level} )
             && ( $msg_level <= $self->{max_level} ) );
 }
 
 sub _level_as_number {
     my $self  = shift;
     my $level = shift;
 
     unless ( defined $level ) {
         Carp::croak "undefined value provided for log level";
     }
 
     return $level if $level =~ /^\d$/;
 
     unless ( Log::Dispatch->level_is_valid($level) ) {
         Carp::croak "$level is not a valid Log::Dispatch log level";
     }
 
     return $self->{level_numbers}{$level};
 }
 
 sub _level_as_name {
     my $self  = shift;
     my $level = shift;
 
     unless ( defined $level ) {
         Carp::croak "undefined value provided for log level";
     }
 
     return $level unless $level =~ /^\d$/;
 
     return $self->{level_names}[$level];
 }
 
 my $_unique_name_counter = 0;
 
 sub _unique_name {
     my $self = shift;
 
     return '_anon_' . $_unique_name_counter++;
 }
 
 sub _add_newline_callback {
 
     +{@_}->{message} . "\n";
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/Screen.pm ###
 package Log::Dispatch::Screen;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Output;
 
 use base qw( Log::Dispatch::Output );
 
 use Encode qw( encode );
 use IO::Handle;
 use Params::Validate qw(validate BOOLEAN);
 Params::Validate::validation_options( allow_extra => 1 );
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     my %p = validate(
         @_, {
             stderr => {
                 type    => BOOLEAN,
                 default => 1,
             },
             utf8 => {
                 type    => BOOLEAN,
                 default => 0,
             },
         }
     );
 
     my $self = bless \%p, $class;
     $self->_basic_init(%p);
 
     return $self;
 }
 
 sub log_message {
     my $self = shift;
     my %p    = @_;
 
     my $message
         = $self->{utf8} ? encode( 'UTF-8', $p{message} ) : $p{message};
     if ( $self->{stderr} ) {
         print STDERR $message;
     }
     else {
         print STDOUT $message;
     }
 }
 
 1;
 
 
 __END__
 
### Log/Dispatch/Syslog.pm ###
 package Log::Dispatch::Syslog;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.51';
 
 use Log::Dispatch::Output;
 
 use base qw( Log::Dispatch::Output );
 
 use Params::Validate qw(validate ARRAYREF BOOLEAN HASHREF SCALAR);
 Params::Validate::validation_options( allow_extra => 1 );
 
 use Scalar::Util qw( reftype );
 use Sys::Syslog 0.28 ();
 
 sub new {
     my $proto = shift;
     my $class = ref $proto || $proto;
 
     my %p = @_;
 
     my $self = bless {}, $class;
 
     $self->_basic_init(%p);
     $self->_init(%p);
 
     return $self;
 }
 
 my ($Ident) = $0 =~ /(.+)/;
 
 my $thread_lock;
 my $threads_loaded;
 
 sub _init {
     my $self = shift;
 
     my %p = validate(
         @_, {
             ident => {
                 type    => SCALAR,
                 default => $Ident
             },
             logopt => {
                 type    => SCALAR,
                 default => ''
             },
             facility => {
                 type    => SCALAR,
                 default => 'user'
             },
             socket => {
                 type    => SCALAR | ARRAYREF | HASHREF,
                 default => undef
             },
             lock => {
                 type    => BOOLEAN,
                 default => 0,
             },
         }
     );
 
     $self->{$_} = $p{$_} for qw( ident logopt facility socket lock );
     if ( $self->{lock} ) {
 
         eval 'use threads; use threads::shared'
             unless $threads_loaded;
         $threads_loaded = 1;
         threads::shared::share( \$thread_lock );
     }
 
     $self->{priorities} = [
         'DEBUG',
         'INFO',
         'NOTICE',
         'WARNING',
         'ERR',
         'CRIT',
         'ALERT',
         'EMERG'
     ];
 }
 
 sub log_message {
     my $self = shift;
     my %p    = @_;
 
     my $pri = $self->_level_as_number( $p{level} );
 
     lock($thread_lock) if $self->{lock};
 
     eval {
         if ( defined $self->{socket} ) {
             Sys::Syslog::setlogsock(
                 ref $self->{socket} && reftype( $self->{socket} ) eq 'ARRAY'
                 ? @{ $self->{socket} }
                 : $self->{socket}
             );
         }
 
         Sys::Syslog::openlog(
             $self->{ident},
             $self->{logopt},
             $self->{facility}
         );
         Sys::Syslog::syslog( $self->{priorities}[$pri], $p{message} );
         Sys::Syslog::closelog;
     };
 
     warn $@ if $@ and $^W;
 }
 
 1;
 
 
 __END__
 
### Log/Log4perl.pm ###
 package Log::Log4perl;
 
 END { local($?); Log::Log4perl::Logger::cleanup(); }
 
 use 5.006;
 use strict;
 use warnings;
 
 use Log::Log4perl::Util;
 use Log::Log4perl::Logger;
 use Log::Log4perl::Level;
 use Log::Log4perl::Config;
 use Log::Log4perl::Appender;
 
 our $VERSION = '1.46';
 
 our $caller_depth = 0;
 
 our %ALLOWED_CODE_OPS = (
     'safe'        => [ ':browse' ],
     'restrictive' => [ ':default' ],
 );
 
 our %WRAPPERS_REGISTERED = map { $_ => 1 } qw(Log::Log4perl);
 
 our @ALLOWED_CODE_OPS_IN_CONFIG_FILE;
 
 our %VARS_SHARED_WITH_SAFE_COMPARTMENT = (
     main => [ '%ENV' ],
 );
 
 our $ALLOW_CODE_IN_CONFIG_FILE = 1;
 
 our $JOIN_MSG_ARRAY_CHAR = '';
 
 our $DOM_VERSION_REQUIRED = '1.29'; 
 
 our $CHATTY_DESTROY_METHODS = 0;
 
 our $LOGDIE_MESSAGE_ON_STDERR = 1;
 our $LOGEXIT_CODE             = 1;
 our %IMPORT_CALLED;
 
 our $EASY_CLOSURES = {};
 
 our $STRINGIFY_DIE_MESSAGE = 1;
 
 use constant _INTERNAL_DEBUG => 0;
 
 sub import {
     my($class) = shift;
 
     my $caller_pkg = caller();
 
     return 1 if $IMPORT_CALLED{$caller_pkg}++;
 
     my(%tags) = map { $_ => 1 } @_;
 
     if(exists $tags{':easy'}) {
         $tags{':levels'} = 1;
         $tags{':nowarn'} = 1;
         $tags{'get_logger'} = 1;
     }
 
     if(exists $tags{':no_extra_logdie_message'}) {
         $Log::Log4perl::LOGDIE_MESSAGE_ON_STDERR = 0;
         delete $tags{':no_extra_logdie_message'};
     }
 
     if(exists $tags{get_logger}) {
         no strict qw(refs);
         *{"$caller_pkg\::get_logger"} = *get_logger;
 
         delete $tags{get_logger};
     }
 
     if(exists $tags{':levels'}) {
         for my $key (keys %Log::Log4perl::Level::PRIORITY) {
             my $name  = "$caller_pkg\::$key";
             my $value = $
                         Log::Log4perl::Level::PRIORITY{$key};
             no strict qw(refs);
             *{"$name"} = \$value;
         }
 
         delete $tags{':levels'};
     }
 
     if(exists $tags{':easy'}) {
         delete $tags{':easy'};
 
         my $logger = get_logger("$caller_pkg");
         
         for(qw(TRACE DEBUG INFO WARN ERROR FATAL ALWAYS)) {
             my $level   = $_;
             $level = "OFF" if $level eq "ALWAYS";
             my $lclevel = lc($_);
             easy_closure_create($caller_pkg, $_, sub {
                 Log::Log4perl::Logger::init_warn() unless 
                     $Log::Log4perl::Logger::INITIALIZED or
                     $Log::Log4perl::Logger::NON_INIT_WARNED;
                 $logger->{$level}->($logger, @_, $level);
             }, $logger);
         }
 
         for(qw(LOGCROAK LOGCLUCK LOGCARP LOGCONFESS)) {
             my $method = "Log::Log4perl::Logger::" . lc($_);
 
             easy_closure_create($caller_pkg, $_, sub {
                 unshift @_, $logger;
                 goto &$method;
             }, $logger);
         }
 
          easy_closure_create($caller_pkg, "LOGDIE", sub {
              Log::Log4perl::Logger::init_warn() unless 
                      $Log::Log4perl::Logger::INITIALIZED or
                      $Log::Log4perl::Logger::NON_INIT_WARNED;
              $logger->{FATAL}->($logger, @_, "FATAL");
              $Log::Log4perl::LOGDIE_MESSAGE_ON_STDERR ?
                  CORE::die(Log::Log4perl::Logger::callerline(join '', @_)) :
                  exit $Log::Log4perl::LOGEXIT_CODE;
          }, $logger);
 
          easy_closure_create($caller_pkg, "LOGEXIT", sub {
             Log::Log4perl::Logger::init_warn() unless 
                     $Log::Log4perl::Logger::INITIALIZED or
                     $Log::Log4perl::Logger::NON_INIT_WARNED;
             $logger->{FATAL}->($logger, @_, "FATAL");
             exit $Log::Log4perl::LOGEXIT_CODE;
          }, $logger);
 
         easy_closure_create($caller_pkg, "LOGWARN", sub {
             Log::Log4perl::Logger::init_warn() unless 
                     $Log::Log4perl::Logger::INITIALIZED or
                     $Log::Log4perl::Logger::NON_INIT_WARNED;
             $logger->{WARN}->($logger, @_, "WARN");
             CORE::warn(Log::Log4perl::Logger::callerline(join '', @_))
                 if $Log::Log4perl::LOGDIE_MESSAGE_ON_STDERR;
         }, $logger);
     }
 
     if(exists $tags{':nowarn'}) {
         $Log::Log4perl::Logger::NON_INIT_WARNED = 1;
         delete $tags{':nowarn'};
     }
 
     if(exists $tags{':nostrict'}) {
         $Log::Log4perl::Logger::NO_STRICT = 1;
         delete $tags{':nostrict'};
     }
 
     if(exists $tags{':resurrect'}) {
         my $FILTER_MODULE = "Filter::Util::Call";
         if(! Log::Log4perl::Util::module_available($FILTER_MODULE)) {
             die "$FILTER_MODULE required with :resurrect" .
                 "(install from CPAN)";
         }
         eval "require $FILTER_MODULE" or die "Cannot pull in $FILTER_MODULE";
         Filter::Util::Call::filter_add(
             sub {
                 my($status);
                 s/^\s*###l4p// if
                     ($status = Filter::Util::Call::filter_read()) > 0;
                 $status;
                 });
         delete $tags{':resurrect'};
     }
 
     if(keys %tags) {
         die "Unknown Option(s): @{[keys %tags]}";
     }
 }
 
 sub initialized {
     return $Log::Log4perl::Logger::INITIALIZED;
 }
 
 sub new {
     die "THIS CLASS ISN'T FOR DIRECT USE. " .
         "PLEASE CHECK 'perldoc " . __PACKAGE__ . "'.";
 }
 
 sub reset { 
     return Log::Log4perl::Logger->reset();
 }
 
 sub init_once { 
     init(@_) unless $Log::Log4perl::Logger::INITIALIZED;
 }
 
 sub init { 
     my($class, @args) = @_;
 
     if ($class ne __PACKAGE__) {
         unshift(@args, $class);
     }
 
     return Log::Log4perl::Config->init(@args);
 }
 
 sub init_and_watch { 
     my($class, @args) = @_;
 
     if ($class ne __PACKAGE__) {
         unshift(@args, $class);
     }
 
     return Log::Log4perl::Config->init_and_watch(@args);
 }
 
 
 sub easy_init { 
     my($class, @args) = @_;
 
     if(ref($class) or $class =~ /^\d+$/) {
         unshift @args, $class;
     }
 
     Log::Log4perl->reset();
 
     my @loggers = ();
 
     my %default = ( level    => $DEBUG,
                     file     => "STDERR",
                     utf8     => undef,
                     category => "",
                     layout   => "%d %m%n",
                   );
 
     if(!@args) {
         push @loggers, \%default;
     } else {
         for my $arg (@args) {
             if($arg =~ /^\d+$/) {
                 my %logger = (%default, level => $arg);
                 push @loggers, \%logger;
             } elsif(ref($arg) eq "HASH") {
                 my %logger = (%default, %$arg);
                 push @loggers, \%logger;
             }
         }
     }
 
     for my $logger (@loggers) {
 
         my $app;
 
         if($logger->{file} =~ /^stderr$/i) {
             $app = Log::Log4perl::Appender->new(
                 "Log::Log4perl::Appender::Screen",
                 utf8 => $logger->{utf8});
         } elsif($logger->{file} =~ /^stdout$/i) {
             $app = Log::Log4perl::Appender->new(
                 "Log::Log4perl::Appender::Screen",
                 stderr => 0,
                 utf8   => $logger->{utf8});
         } else {
             my $binmode;
             if($logger->{file} =~ s/^(:.*?)>/>/) {
                 $binmode = $1;
             }
             $logger->{file} =~ /^(>)?(>)?/;
             my $mode = ($2 ? "append" : "write");
             $logger->{file} =~ s/.*>+\s*//g;
             $app = Log::Log4perl::Appender->new(
                 "Log::Log4perl::Appender::File",
                 filename => $logger->{file},
                 mode     => $mode,
                 utf8     => $logger->{utf8},
                 binmode  => $binmode,
             );
         }
 
         my $layout = Log::Log4perl::Layout::PatternLayout->new(
                                                         $logger->{layout});
         $app->layout($layout);
 
         my $log = Log::Log4perl->get_logger($logger->{category});
         $log->level($logger->{level});
         $log->add_appender($app);
     }
 
     $Log::Log4perl::Logger::INITIALIZED = 1;
 }
 
 sub wrapper_register {  
     my $wrapper = $_[-1];
 
     $WRAPPERS_REGISTERED{ $wrapper } = 1;
 }
 
 sub get_logger {  
 
 
     my $category;
 
     if(@_ == 0) {
         my $level = 0;
         do { $category = scalar caller($level++);
         } while exists $WRAPPERS_REGISTERED{ $category };
 
     } elsif(@_ == 1) {
         $category = $_[0];
 
         my $level = 0;
         while(exists $WRAPPERS_REGISTERED{ $category }) { 
             $category = scalar caller($level++);
         }
 
     } else {
         $category = $_[1];
     }
 
     return Log::Log4perl::Logger->get_logger($category);
 }
 
 sub caller_depth_offset {
     my( $level ) = @_;
 
     my $category;
 
     { 
         my $category = scalar caller($level + 1);
 
         if(defined $category and
            exists $WRAPPERS_REGISTERED{ $category }) {
             $level++;
             redo;
         }
     }
 
     return $level;
 }
 
 sub appenders {  
     return \%Log::Log4perl::Logger::APPENDER_BY_NAME;
 }
 
 sub add_appender { 
     my($class, $appender) = @_;
 
     my $name = $appender->name();
     die "Mandatory parameter 'name' missing in appender" unless defined $name;
 
     Log::Log4perl->appenders()->{ $name } = $appender;
 }
 
 sub appender_thresholds_adjust {  
     shift if $_[0] eq __PACKAGE__;
     my($delta, $appenders) = @_;
 	my $retval = 0;
 
     if($delta == 0) {
         return;
     }
 
     if(defined $appenders) {
         $appenders = [map { 
                        die "Unkown appender: '$_'" unless exists
                           $Log::Log4perl::Logger::APPENDER_BY_NAME{
                             $_};
                        $Log::Log4perl::Logger::APPENDER_BY_NAME{
                          $_} 
                       } @$appenders];
     } else {
         $appenders = [values %{Log::Log4perl::appenders()}] unless 
             defined $appenders;
     }
 
     foreach my $app (@$appenders) {
         my $old_thres = $app->threshold();
         my $new_thres;
         if($delta > 0) {
             $new_thres = Log::Log4perl::Level::get_higher_level(
                              $old_thres, $delta);
         } else {
             $new_thres = Log::Log4perl::Level::get_lower_level(
                              $old_thres, -$delta);
         }
 
         ++$retval if ($app->threshold($new_thres) == $new_thres);
     }
 	return $retval;
 }
 
 sub appender_by_name {  
     shift if $_[0] eq __PACKAGE__;
 
     my($name) = @_;
 
     if(defined $name and
        exists $Log::Log4perl::Logger::APPENDER_BY_NAME{
                  $name}) {
         return $Log::Log4perl::Logger::APPENDER_BY_NAME{
                  $name}->{appender};
     } else {
         return undef;
     }
 }
 
 sub eradicate_appender {  
     shift if $_[0] eq __PACKAGE__;
     Log::Log4perl::Logger->eradicate_appender(@_);
 }
 
 sub infiltrate_lwp {  
     no warnings qw(redefine);
 
     my $l4p_wrapper = sub {
         my($prio, @message) = @_;
         local $Log::Log4perl::caller_depth =
               $Log::Log4perl::caller_depth + 2;
         get_logger(scalar caller(1))->log($prio, @message);
     };
 
     *LWP::Debug::trace = sub { 
         $l4p_wrapper->($INFO, @_); 
     };
     *LWP::Debug::conns =
     *LWP::Debug::debug = sub { 
         $l4p_wrapper->($DEBUG, @_); 
     };
 }
 
 sub easy_closure_create {
     my($caller_pkg, $entry, $code, $logger) = @_;
 
     no strict 'refs';
 
     print("easy_closure: Setting shortcut $caller_pkg\::$entry ", 
          "(logger=$logger\n") if _INTERNAL_DEBUG;
 
     $EASY_CLOSURES->{ $caller_pkg }->{ $entry } = $logger;
     *{"$caller_pkg\::$entry"} = $code;
 }
 
 sub easy_closure_cleanup {
     my($caller_pkg, $entry) = @_;
 
     no warnings 'redefine';
     no strict 'refs';
 
     my $logger = $EASY_CLOSURES->{ $caller_pkg }->{ $entry };
 
     print("easy_closure: Nuking easy shortcut $caller_pkg\::$entry ", 
          "(logger=$logger\n") if _INTERNAL_DEBUG;
 
     *{"$caller_pkg\::$entry"} = sub { };
     delete $EASY_CLOSURES->{ $caller_pkg }->{ $entry };
 }
 
 sub easy_closure_category_cleanup {
     my($caller_pkg) = @_;
 
     if(! exists $EASY_CLOSURES->{ $caller_pkg } ) {
         return 1;
     }
 
     for my $entry ( keys %{ $EASY_CLOSURES->{ $caller_pkg } } ) {
         easy_closure_cleanup( $caller_pkg, $entry );
     }
 
     delete $EASY_CLOSURES->{ $caller_pkg };
 }
 
 sub easy_closure_global_cleanup {
 
     for my $caller_pkg ( keys %$EASY_CLOSURES ) {
         easy_closure_category_cleanup( $caller_pkg );
     }
 }
 
 sub easy_closure_logger_remove {
     my($class, $logger) = @_;
 
     PKG: for my $caller_pkg ( keys %$EASY_CLOSURES ) {
         for my $entry ( keys %{ $EASY_CLOSURES->{ $caller_pkg } } ) {
             if( $logger == $EASY_CLOSURES->{ $caller_pkg }->{ $entry } ) {
                 easy_closure_category_cleanup( $caller_pkg );
                 next PKG;
             }
         }
     }
 }
 
 sub remove_logger {
     my ($class, $logger) = @_;
 
     Log::Log4perl->easy_closure_logger_remove( $logger );
 
     delete $Log::Log4perl::Logger::LOGGERS_BY_NAME->{ $logger->{category} };
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender.pm ###
 package Log::Log4perl::Appender;
 
 use 5.006;
 use strict;
 use warnings;
 
 use Log::Log4perl::Config;
 use Log::Log4perl::Level;
 use Carp;
 
 use constant _INTERNAL_DEBUG => 0;
 
 our $unique_counter = 0;
 
 sub reset {
     $unique_counter = 0;
 }
 
 sub unique_name {
     $unique_counter++;
     my $unique_name = sprintf("app%03d", $unique_counter);
     return $unique_name;
 }
 
 sub new {
     my($class, $appenderclass, %params) = @_;
 
     eval {
 
         die "'$appenderclass' not a valid class name " if 
             $appenderclass =~ /[^:\w]/;
 
 
         if( ! $appenderclass->can('new') ) {
             eval "require $appenderclass";
             die $@ if $@;
         }
     };
 
     $@ and die "ERROR: can't load appenderclass '$appenderclass'\n$@";
 
     $params{name} = unique_name() unless exists $params{name};
 
     if ($appenderclass eq 'Log::Dispatch::File' &&
         ! exists $params{mode}) {
         $params{mode} = 'append';
     }
 
     my $appender = $appenderclass->new(
         min_level => 'debug',
         map { $_ => $params{$_} } keys %params,
     );
 
     my $self = {
                  appender  => $appender,
                  name      => $params{name},
                  layout    => undef,
                  level     => $ALL,
                  composite => 0,
                };
 
     $self->{warp_message} = $params{warp_message};
     if($self->{warp_message} and
        my $cref = 
        Log::Log4perl::Config::compile_if_perl($self->{warp_message})) {
         $self->{warp_message} = $cref;
     }
     
     bless $self, $class;
 
     return $self;
 }
 
 sub composite { 
     my ($self, $flag) = @_;
 
     $self->{composite} = $flag if defined $flag;
     return $self->{composite};
 }
 
 sub threshold { 
     my ($self, $level) = @_;
 
     print "Setting threshold to $level\n" if _INTERNAL_DEBUG;
 
     if(defined $level) {
         $self->{level} = ($level =~ /^(\d+)$/) ? $level :
             Log::Log4perl::Level::to_priority($level);
     }
 
     return $self->{level};
 }
 
 sub log { 
     my ($self, $p, $category, $level, $cache) = @_;
 
     if($self->{level} > $
                         Log::Log4perl::Level::PRIORITY{$level}) {
         print "$self->{level} > $level, aborting\n" if _INTERNAL_DEBUG;
         return undef;
     }
 
     if($self->{filter}) {
         if($self->{filter}->ok(%$p,
                                log4p_category => $category,
                                log4p_level    => $level )) {
             print "Filter $self->{filter}->{name} passes\n" if _INTERNAL_DEBUG;
         } else {
             print "Filter $self->{filter}->{name} blocks\n" if _INTERNAL_DEBUG;
             return undef;
         }
     }
 
     unless($self->composite()) {
 
         if (! defined $self->{warp_message} ){
             if (ref $p->{message} eq "ARRAY") {
                 for my $i (0..$#{$p->{message}}) {
                     if( !defined $p->{message}->[ $i ] ) {
                         local $Carp::CarpLevel =
                         $Carp::CarpLevel + $Log::Log4perl::caller_depth + 1;
                         carp "Warning: Log message argument #" . 
                              ($i+1) . " undefined";
                     }
                 }
                 $p->{message} = 
                     join($Log::Log4perl::JOIN_MSG_ARRAY_CHAR, 
                          @{$p->{message}} 
                          );
             }
             
         } elsif (! $self->{warp_message}) {
             ;  
     
         } elsif (ref($self->{warp_message}) eq "CODE") {
             $p->{message} = 
                 [$self->{warp_message}->(@{$p->{message}})];
         } else {
             no strict qw(refs);
             $p->{message} = 
                 [$self->{warp_message}->(@{$p->{message}})];
         }
 
         $p->{message} = $self->{layout}->render($p->{message}, 
             $category,
             $level,
             3 + $Log::Log4perl::caller_depth,
         ) if $self->layout();
     }
 
     my $args = [%$p, log4p_category => $category, log4p_level => $level];
 
     if(defined $cache) {
         $$cache = $args;
     } else {
         $self->{appender}->log(@$args);
     }
 
     return 1;
 }
 
 sub log_cached {
     my ($self, $cache) = @_;
 
     $self->{appender}->log(@$cache);
 }
 
 sub name { 
     my($self, $name) = @_;
 
     if($name) {
         $self->{name} = $name;
     }
 
     return $self->{name};
 }
 
 sub layout { 
     my($self, $layout) = @_;
 
     if($layout) {
         $self->{layout} = $layout;
 
     }elsif (! $self->{layout}) {
         $self->{layout} = Log::Log4perl::Layout::SimpleLayout
                                                 ->new($self->{name});
 
     }
 
     return $self->{layout};
 }
 
 sub filter { 
     my ($self, $filter) = @_;
 
     if($filter) {
         print "Setting filter to $filter->{name}\n" if _INTERNAL_DEBUG;
         $self->{filter} = $filter;
     }
 
     return $self->{filter};
 }
 
 sub AUTOLOAD { 
     my $self = shift;
 
     no strict qw(vars);
 
     $AUTOLOAD =~ s/.*:://;
 
     if(! defined $self->{appender}) {
         die "Can't locate object method $AUTOLOAD() in ", __PACKAGE__;
     }
 
     return $self->{appender}->$AUTOLOAD(@_);
 }
 
 sub DESTROY {
     foreach my $key (keys %{$_[0]}) {
         delete $_[0]->{$key};
     }
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/Buffer.pm ###
 
 package Log::Log4perl::Appender::Buffer;
 
 use strict;
 use warnings;
 
 our @ISA = qw(Log::Log4perl::Appender);
 
 our $CVSVERSION   = '$Revision: 1.2 $';
 our ($VERSION)    = ($CVSVERSION =~ /(\d+\.\d+)/);
 
 sub new {
     my($class, %options) = @_;
 
     my $self = {
         appender=> undef,
         buffer  => [],
         options => { 
             max_messages  => undef, 
             trigger       => undef,
             trigger_level => undef,
         },
         level   => 0,
         %options,
     };
 
     if($self->{trigger_level}) {
         $self->{trigger} = level_trigger($self->{trigger_level});
     }
 
     push @{$options{l4p_depends_on}}, $self->{appender};
 
     push @{$options{l4p_post_config_subs}}, sub { $self->post_init() };
 
     bless $self, $class;
 }
 
 sub log {
     my($self, %params) = @_;
 
     local $Log::Log4perl::caller_depth =
         $Log::Log4perl::caller_depth + 2;
 
     if(defined $self->{max_messages} and
        @{$self->{buffer}} == $self->{max_messages}) {
         shift @{$self->{buffer}};
     }
     $self->{app}->SUPER::log(\%params,
                          $params{log4p_category},
                          $params{log4p_level}, \my $cache);
 
     if( defined $cache ) {
         push @{ $self->{buffer} }, $cache;
     }
 
     $self->flush() if $self->{trigger}->($self, \%params);
 }
 
 sub flush {
     my($self) = @_;
 
     for my $cache (@{$self->{buffer}}) {
         $self->{app}->SUPER::log_cached($cache);
     }
 
     $self->{buffer} = [];
 }
 
 sub post_init {
     my($self) = @_;
 
     if(! exists $self->{appender}) {
        die "No appender defined for " . __PACKAGE__;
     }
 
     my $appenders = Log::Log4perl->appenders();
     my $appender = Log::Log4perl->appenders()->{$self->{appender}};
 
     if(! defined $appender) {
        die "Appender $self->{appender} not defined (yet) when " .
            __PACKAGE__ . " needed it";
     }
 
     $self->{app} = $appender;
 }
 
 sub level_trigger {
     my($level) = @_;
 
     return sub {
         my($self, $params) = @_;
 
         return Log::Log4perl::Level::to_priority(
                  $params->{log4p_level}) >= 
                Log::Log4perl::Level::to_priority($level);
     };
 }
     
 sub DESTROY {
     my($self) = @_;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/DBI.pm ###
 package Log::Log4perl::Appender::DBI;
 
 our @ISA = qw(Log::Log4perl::Appender);
 
 use Carp;
 
 use strict;
 use DBI;
 
 sub new {
     my($proto, %p) = @_;
     my $class = ref $proto || $proto;
 
     my $self = bless {}, $class;
 
     $self->_init(%p);
 
     my %defaults = (
         reconnect_attempts => 1,
         reconnect_sleep    => 0,
     );
 
     for (keys %defaults) {
         if(exists $p{$_}) {
             $self->{$_} = $p{$_};
         } else {
             $self->{$_} = $defaults{$_};
         }
     }
 
     foreach my $pnum (keys %{$p{params}}){
         $self->{bind_value_layouts}{$pnum} = 
                 Log::Log4perl::Layout::PatternLayout->new({
                    ConversionPattern  => {value  => $p{params}->{$pnum}},
                    undef_column_value => undef,
                 });
     }
 
     $self->{SQL} = $p{sql}; 
 
     $self->{MAX_COL_SIZE} = $p{max_col_size};
 
     $self->{BUFFERSIZE} = $p{bufferSize} || 1; 
 
     if ($p{usePreparedStmt}) {
         $self->{sth} = $self->create_statement($p{sql});
         $self->{usePreparedStmt} = 1;
     }else{
         $self->{layout} = Log::Log4perl::Layout::PatternLayout->new({
             ConversionPattern  => {value  => $p{sql}},
             undef_column_value => undef,
         });
     }
 
     if ($self->{usePreparedStmt} &&  $self->{bufferSize}){
         warn "Log4perl: you've defined both usePreparedStmt and bufferSize \n".
         "in your appender '$p{name}'--\n".
         "I'm going to ignore bufferSize and just use a prepared stmt\n";
     }
 
     return $self;
 }
 
 
 sub _init {
     my $self = shift;
     my %params = @_;
 
     if ($params{dbh}) {
         $self->{dbh} = $params{dbh};
     } else {
         $self->{connect} = sub {
             DBI->connect(@params{qw(datasource username password)},
                          {PrintError => 0, $params{attrs} ? %{$params{attrs}} : ()})
                             or croak "Log4perl: $DBI::errstr";
         };
         $self->{dbh} = $self->{connect}->();
         $self->{_mine} = 1;
     }
 }
 
 sub create_statement {
     my ($self, $stmt) = @_;
 
     $stmt || croak "Log4perl: sql not set in Log4perl::Appender::DBI";
 
     return $self->{dbh}->prepare($stmt) || croak "Log4perl: DBI->prepare failed $DBI::errstr\n$stmt";
 
 }
 
 
 sub log {
     my $self = shift;
     my %p = @_;
 
 
     chomp $p{message} unless ref $p{message}; 
 
         
     my $qmarks = $self->calculate_bind_values(\%p);
 
 
     if ($self->{usePreparedStmt}) {
 
         $self->query_execute($self->{sth}, @$qmarks);
 
     }else{
 
         my $stmt = $self->{layout}->render(
                         $p{message},
                         $p{log4p_category},
                         $p{log4p_level},
                         5 + $Log::Log4perl::caller_depth,  
                         );
 
         push @{$self->{BUFFER}}, $stmt, $qmarks;
 
         $self->check_buffer();
     }
 }
 
 sub query_execute {
     my($self, $sth, @qmarks) = @_;
 
     my $errstr = "[no error]";
 
     for my $attempt (0..$self->{reconnect_attempts}) {
         if(! $sth->execute(@qmarks)) {
 
                 $errstr = $self->{dbh}->errstr();
 
                 if($self->{dbh}->ping()) {
                     croak "Log4perl: DBI appender error: '$errstr'";
                 }
 
                 if($attempt == $self->{reconnect_attempts}) {
                     croak "Log4perl: DBI appender failed to " .
                           ($self->{reconnect_attempts} == 1 ? "" : "re") .
                           "connect " .
                           "to database after " .
                           "$self->{reconnect_attempts} attempt" .
                           ($self->{reconnect_attempts} == 1 ? "" : "s") .
                           " (last error error was [$errstr]";
                 }
             if(! $self->{dbh}->ping()) {
                 if($attempt) {
                     sleep($self->{reconnect_sleep}) if $self->{reconnect_sleep};
                 }
 
                 eval {
                     $self->{dbh} = $self->{connect}->();
                 };
             }
 
             if ($self->{usePreparedStmt}) {
                 $sth = $self->create_statement($self->{SQL});
                 $self->{sth} = $sth if $self->{sth};
             } else {
                 $sth = $self->create_statement($self->{pending_stmt});
             }
 
             next;
         }
         return 1;
     }
     croak "Log4perl: DBI->execute failed $errstr, \n".
           "on $self->{SQL}\n @qmarks";
 }
 
 sub calculate_bind_values {
     my ($self, $p) = @_;
 
     my @qmarks;
     my $user_ph_idx = 0;
 
     my $i=0;
     
     if ($self->{bind_value_layouts}) {
 
         my $prev_pnum = 0;
         my $max_pnum = 0;
     
         my @pnums = sort {$a <=> $b} keys %{$self->{bind_value_layouts}};
         $max_pnum = $pnums[-1];
         
         foreach my $pnum (1..$max_pnum){
             my $msg;
     
             if ($self->{bind_value_layouts}{$pnum}){
                $msg = $self->{bind_value_layouts}{$pnum}->render(
                         $p->{message},
                         $p->{log4p_category},
                         $p->{log4p_level},
                         5 + $Log::Log4perl::caller_depth,  
                     );
 
             }elsif (ref $p->{message} eq 'ARRAY' && @{$p->{message}}){
                 $msg = $p->{message}->[$i++];
 
             }elsif (ref $p->{message} eq 'ARRAY'){
                 $msg = undef;
                 $p->{message} = undef;
 
             }elsif (! ref $p->{message} ){
                 $msg = $p->{message};
                 $p->{message} = undef;
 
             }
 
             if ($self->{MAX_COL_SIZE} &&
                 length($msg) > $self->{MAX_COL_SIZE}){
                 substr($msg, $self->{MAX_COL_SIZE}) = '';
             }
             push @qmarks, $msg;
         }
     }
 
     if (ref $p->{message} eq 'ARRAY' && @{$p->{message}} ) {
         push @qmarks, @{$p->{message}}[$i..@{$p->{message}}-1];
 
     }
 
     return \@qmarks;
 }
 
 
 sub check_buffer {
     my $self = shift;
 
     return unless ($self->{BUFFER} && ref $self->{BUFFER} eq 'ARRAY');
 
     if (scalar @{$self->{BUFFER}} >= $self->{BUFFERSIZE} * 2) {
 
         my ($sth, $stmt, $prev_stmt);
 
         $prev_stmt = ""; 
 
         while (@{$self->{BUFFER}}) {
             my ($stmt, $qmarks) = splice (@{$self->{BUFFER}},0,2);
 
             $self->{pending_stmt} = $stmt;
 
             if ($stmt ne $prev_stmt) {
                 $sth->finish if $sth;
                 $sth = $self->create_statement($stmt);
             }
 
             $self->query_execute($sth, @$qmarks);
 
             $prev_stmt = $stmt;
 
         }
 
         $sth->finish;
 
         my $dbh = $self->{dbh};
 
         if ($dbh && ! $dbh->{AutoCommit}) {
             $dbh->commit;
         }
     }
 }
 
 sub DESTROY {
     my $self = shift;
 
     $self->{BUFFERSIZE} = 1;
 
     $self->check_buffer();
 
     if ($self->{_mine} && $self->{dbh}) {
         $self->{dbh}->disconnect;
     }
 }
 
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/File.pm ###
 package Log::Log4perl::Appender::File;
 
 our @ISA = qw(Log::Log4perl::Appender);
 
 use warnings;
 use strict;
 use Log::Log4perl::Config::Watch;
 use Fcntl;
 use File::Path;
 use File::Spec::Functions qw(splitpath);
 use constant _INTERNAL_DEBUG => 0;
 
 sub new {
     my($class, @options) = @_;
 
     my $self = {
         name      => "unknown name",
         umask     => undef,
         owner     => undef,
         group     => undef,
         autoflush => 1,
         syswrite  => 0,
         mode      => "append",
         binmode   => undef,
         utf8      => undef,
         recreate  => 0,
         recreate_check_interval => 30,
         recreate_check_signal   => undef,
         recreate_pid_write      => undef,
         create_at_logtime       => 0,
         header_text             => undef,
         mkpath                  => 0,
         mkpath_umask            => 0,
         @options,
     };
 
     if($self->{create_at_logtime}) {
         $self->{recreate}  = 1;
     }
     for my $param ('umask', 'mkpath_umask') {
         if(defined $self->{$param} and $self->{$param} =~ /^0/) {
             $self->{$param} = oct($self->{$param});
         }
     }
 
     die "Mandatory parameter 'filename' missing" unless
         exists $self->{filename};
 
     bless $self, $class;
 
     if($self->{recreate_pid_write}) {
         print "Creating pid file",
               " $self->{recreate_pid_write}\n" if _INTERNAL_DEBUG;
         open FILE, ">$self->{recreate_pid_write}" or
             die "Cannot open $self->{recreate_pid_write}";
         print FILE "$$\n";
         close FILE;
     }
 
     $self->file_open() unless $self->{create_at_logtime};
 
     return $self;
 }
 
 sub filename {
     my($self) = @_;
 
     return $self->{filename};
 }
 
 sub file_open {
     my($self) = @_;
 
     my $arrows  = ">";
     my $sysmode = (O_CREAT|O_WRONLY);
 
 
     if($self->{mode} eq "append") {
         $arrows   = ">>";
         $sysmode |= O_APPEND;
     } elsif ($self->{mode} eq "pipe") {
         $arrows = "|";
     } else {
         $sysmode |= O_TRUNC;
     }
 
     my $fh = do { local *FH; *FH; };
 
 
     my $didnt_exist = ! -e $self->{filename};
     if($didnt_exist && $self->{mkpath}) {
         my ($volume, $path, $file) = splitpath($self->{filename});
         if($path ne '' && !-e $path) {
             my $old_umask = umask($self->{mkpath_umask}) if defined $self->{mkpath_umask};
             my $options = {};
             foreach my $param (qw(owner group) ) {
                 $options->{$param} = $self->{$param} if defined $self->{$param};
             }
             eval {
                 mkpath($path,$options);
             };
             umask($old_umask) if defined $old_umask;
             die "Can't create path ${path} ($!)" if $@;
         }
     }
 
     my $old_umask = umask($self->{umask}) if defined $self->{umask};
 
     eval {
         if($self->{syswrite}) {
             sysopen $fh, "$self->{filename}", $sysmode or
                 die "Can't sysopen $self->{filename} ($!)";
         } else {
             open $fh, "$arrows$self->{filename}" or
                 die "Can't open $self->{filename} ($!)";
         }
     };
     umask($old_umask) if defined $old_umask;
     die $@ if $@;
 
     if($didnt_exist and
          ( defined $self->{owner} or defined $self->{group} )
       ) {
 
         eval { $self->perms_fix() };
 
         if($@) {
             unlink $self->{filename};
             die $@;
         }
     }
 
     if($self->{recreate}) {
         $self->{watcher} = Log::Log4perl::Config::Watch->new(
             file           => $self->{filename},
             (defined $self->{recreate_check_interval} ?
               (check_interval => $self->{recreate_check_interval}) : ()),
             (defined $self->{recreate_check_signal} ?
               (signal => $self->{recreate_check_signal}) : ()),
         );
     }
 
     $self->{fh} = $fh;
 
     if ($self->{autoflush} and ! $self->{syswrite}) {
         my $oldfh = select $self->{fh};
         $| = 1;
         select $oldfh;
     }
 
     if (defined $self->{binmode}) {
         binmode $self->{fh}, $self->{binmode};
     }
 
     if (defined $self->{utf8}) {
         binmode $self->{fh}, ":utf8";
     }
 
     if(defined $self->{header_text}) {
         if( $self->{header_text} !~ /\n\Z/ ) {
             $self->{header_text} .= "\n";
         }
         my $fh = $self->{fh};
         print $fh $self->{header_text};
     }
 }
 
 sub file_close {
     my($self) = @_;
 
     if(defined $self->{fh}) {
         $self->close_with_care( $self->{ fh } );
     }
 
     undef $self->{fh};
 }
 
 sub perms_fix {
     my($self) = @_;
 
     my ($uid_org, $gid_org) = (stat $self->{filename})[4,5];
 
     my ($uid, $gid) = ($uid_org, $gid_org);
 
     if(!defined $uid) {
         die "stat of $self->{filename} failed ($!)";
     }
 
     my $needs_fixing = 0;
 
     if(defined $self->{owner}) {
         $uid = $self->{owner};
         if($self->{owner} !~ /^\d+$/) {
             $uid = (getpwnam($self->{owner}))[2];
             die "Unknown user: $self->{owner}" unless defined $uid;
         }
     }
 
     if(defined $self->{group}) {
         $gid = $self->{group};
         if($self->{group} !~ /^\d+$/) {
             $gid = getgrnam($self->{group});
 
             die "Unknown group: $self->{group}" unless defined $gid;
         }
     }
     if($uid != $uid_org or $gid != $gid_org) {
         chown($uid, $gid, $self->{filename}) or
             die "chown('$uid', '$gid') on '$self->{filename}' failed: $!";
     }
 }
 
 sub file_switch {
     my($self, $new_filename) = @_;
 
     print "Switching file from $self->{filename} to $new_filename\n" if
         _INTERNAL_DEBUG;
 
     $self->file_close();
     $self->{filename} = $new_filename;
     $self->file_open();
 }
 
 sub log {
     my($self, %params) = @_;
 
     if($self->{recreate}) {
         if($self->{recreate_check_signal}) {
             if(!$self->{watcher} or
                $self->{watcher}->{signal_caught}) {
                 $self->file_switch($self->{filename});
                 $self->{watcher}->{signal_caught} = 0;
             }
         } else {
             if(!$self->{watcher} or
                 $self->{watcher}->file_has_moved()) {
                 $self->file_switch($self->{filename});
             }
         }
     }
 
     my $fh = $self->{fh};
 
     if($self->{syswrite}) {
        defined (syswrite $fh, $params{message}) or
            die "Cannot syswrite to '$self->{filename}': $!";
     } else {
         print $fh $params{message} or
             die "Cannot write to '$self->{filename}': $!";
     }
 }
 
 sub DESTROY {
     my($self) = @_;
 
     if ($self->{fh}) {
         my $fh = $self->{fh};
         $self->close_with_care( $fh );
     }
 }
 
 sub close_with_care {
     my( $self, $fh ) = @_;
 
     my $prev_rc = $?;
 
     my $rc = close $fh;
 
     if( !$rc ) {
         if( $self->{ mode } eq "pipe" and
             $!{ ECHILD } ) {
             if( $Log::Log4perl::CHATTY_DESTROY_METHODS ) {
                 warn "$$: pipe closed with ECHILD error -- guess that's ok";
             }
             $? = $prev_rc;
         } else {
             warn "Can't close $self->{filename} ($!)";
         }
     }
 
     return $rc;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/Limit.pm ###
 
 package Log::Log4perl::Appender::Limit;
 
 use strict;
 use warnings;
 use Storable;
 
 our @ISA = qw(Log::Log4perl::Appender);
 
 our $CVSVERSION   = '$Revision: 1.7 $';
 our ($VERSION)    = ($CVSVERSION =~ /(\d+\.\d+)/);
 
 sub new {
     my($class, %options) = @_;
 
     my $self = {
         max_until_flushed   => undef,
         max_until_discarded => undef,
         appender_method_on_flush 
                             => undef,
         appender            => undef,
         accumulate          => 1,
         persistent          => undef,
         block_period        => 3600,
         buffer              => [],
         %options,
     };
 
     push @{$options{l4p_depends_on}}, $self->{appender};
 
     push @{$options{l4p_post_config_subs}}, sub { $self->post_init() };
 
     bless $self, $class;
 
     if(defined $self->{persistent}) {
         $self->restore();
     }
 
     return $self;
 }
 
 sub log {
     my($self, %params) = @_;
     
     local $Log::Log4perl::caller_depth =
         $Log::Log4perl::caller_depth + 2;
 
     my $discard = 0;
     if(defined $self->{max_until_discarded} and
        scalar @{$self->{buffer}} >= $self->{max_until_discarded} - 1) {
         $discard = 1;
     }
 
     my $flush = 0;
     if(defined $self->{max_until_flushed} and
        scalar @{$self->{buffer}} >= $self->{max_until_flushed} - 1) {
         $flush = 1;
     }
 
     if(!$flush and
        (exists $self->{sent_last} and
         $self->{sent_last} + $self->{block_period} > time()
        )
       ) {
         return if $discard;
 
         $self->{app}->SUPER::log(\%params,
                              $params{log4p_category},
                              $params{log4p_level}, \my $cache);
 
         push @{$self->{buffer}}, $cache if $self->{accumulate};
 
         $self->save() if $self->{persistent};
 
         return;
     }
 
 
     $self->flush();
 
     $self->{app}->SUPER::log(\%params,
                              $params{log4p_category},
                              $params{log4p_level});
 
     $self->{sent_last} = time();
 
     $self->save() if $self->{persistent};
 }
 
 sub post_init {
     my($self) = @_;
 
     if(! exists $self->{appender}) {
        die "No appender defined for " . __PACKAGE__;
     }
 
     my $appenders = Log::Log4perl->appenders();
     my $appender = Log::Log4perl->appenders()->{$self->{appender}};
 
     if(! defined $appender) {
        die "Appender $self->{appender} not defined (yet) when " .
            __PACKAGE__ . " needed it";
     }
 
     $self->{app} = $appender;
 }
 
 sub save {
     my($self) = @_;
 
     my $pdata = [$self->{buffer}, $self->{sent_last}];
 
     store $pdata, $self->{persistent} or
         die "Cannot save messages in $self->{persistent} ($!)";
 }
 
 sub restore {
     my($self) = @_;
 
     if(-f $self->{persistent}) {
         my $pdata = retrieve $self->{persistent} or
             die "Cannot retrieve messages from $self->{persistent} ($!)";
         ($self->{buffer}, $self->{sent_last}) = @$pdata;
     }
 }
 
 sub flush {
     my($self) = @_;
 
     for(@{$self->{buffer}}) {
         $self->{app}->SUPER::log_cached($_);
     }
 
     if( $self->{appender_method_on_flush} ) {
         no strict 'refs';
         my $method = $self->{appender_method_on_flush};
         $self->{app}->$method();
     }
 
     $self->{buffer} = [];
 }
 
 sub DESTROY {
     my($self) = @_;
 
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/RRDs.pm ###
 package Log::Log4perl::Appender::RRDs;
 our @ISA = qw(Log::Log4perl::Appender);
 
 use warnings;
 use strict;
 use RRDs;
 
 sub new {
     my($class, @options) = @_;
 
     my $self = {
         name             => "unknown name",
         dbname           => undef,
         rrdupd_params => [],
         @options,
     };
 
     die "Mandatory parameter 'dbname' missing" unless
         defined $self->{dbname};
 
     bless $self, $class;
 
     return $self;
 }
 
 sub log {
     my($self, %params) = @_;
 
 
     RRDs::update($self->{dbname}, 
                  @{$params{rrdupd_params}},
                  $params{message}) or
         die "Cannot update rrd $self->{dbname} ",
             "with $params{message} ($!)";
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/Screen.pm ###
 package Log::Log4perl::Appender::Screen;
 
 our @ISA = qw(Log::Log4perl::Appender);
 
 use warnings;
 use strict;
 
 sub new {
     my($class, @options) = @_;
 
     my $self = {
         name   => "unknown name",
         stderr => 1,
         utf8   => undef,
         @options,
     };
 
     if( $self->{utf8} ) {
         if( $self->{stderr} ) {
             binmode STDERR, ":utf8";
         } else {
             binmode STDOUT, ":utf8";
         }
     }
 
     bless $self, $class;
 }
     
 sub log {
     my($self, %params) = @_;
 
     if($self->{stderr}) {
         print STDERR $params{message};
     } else {
         print $params{message};
     }
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/ScreenColoredLevels.pm ###
 package Log::Log4perl::Appender::ScreenColoredLevels;
 use Log::Log4perl::Appender::Screen;
 our @ISA = qw(Log::Log4perl::Appender::Screen);
 
 use warnings;
 use strict;
 
 use Term::ANSIColor qw();
 use Log::Log4perl::Level;
 
 BEGIN {
     $Term::ANSIColor::EACHLINE="\n";
 }
 
 sub new {
     my($class, %options) = @_;
 
     my %specific_options = ( color => {} );
 
     for my $option ( keys %specific_options ) {
         $specific_options{ $option } = delete $options{ $option } if
             exists $options{ $option };
     }
 
     my $self = $class->SUPER::new( %options );
     @$self{ keys %specific_options } = values %specific_options;
     bless $self, __PACKAGE__; 
 
     for my $level ( keys %{ $self->{color} } ) {
         my $uclevel = uc($level);
         $self->{color}->{$uclevel} = $self->{color}->{$level};
     }
 
     my %default_colors = (
         TRACE   => 'yellow',
         DEBUG   => '',
         INFO    => 'green',
         WARN    => 'blue',
         ERROR   => 'magenta',
         FATAL   => 'red',
     );
     for my $level ( keys %default_colors ) {
         if ( ! exists $self->{ 'color' }->{ $level } ) {
             $self->{ 'color' }->{ $level } = $default_colors{ $level };
         }
     }
 
     bless $self, $class;
 }
     
 sub log {
     my($self, %params) = @_;
 
     my $msg = $params{ 'message' };
 
     if ( my $color = $self->{ 'color' }->{ $params{ 'log4p_level' } } ) {
         $msg = Term::ANSIColor::colored( $msg, $color );
     }
     
     if($self->{stderr}) {
         print STDERR $msg;
     } else {
         print $msg;
     }
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/Socket.pm ###
 package Log::Log4perl::Appender::Socket;
 our @ISA = qw(Log::Log4perl::Appender);
 
 use warnings;
 use strict;
 
 use IO::Socket::INET;
 
 sub new {
     my($class, @options) = @_;
 
     my $self = {
         name            => "unknown name",
         silent_recovery => 0,
         no_warning      => 0,
         PeerAddr        => "localhost",
         Proto           => 'tcp',
         Timeout         => 5,
         @options,
     };
 
     bless $self, $class;
 
     unless ($self->{defer_connection}){
         unless($self->connect(@options)) {
             if($self->{silent_recovery}) {
                 if( ! $self->{no_warning}) {
                     warn "Connect to $self->{PeerAddr}:$self->{PeerPort} failed: $!";
                 }
                return $self;
             }
             die "Connect to $self->{PeerAddr}:$self->{PeerPort} failed: $!";
         }
 
         $self->{socket}->autoflush(1); 
     }
 
     return $self;
 }
     
 sub connect {
     my($self, @options) = @_;
 
     $self->{socket} = IO::Socket::INET->new(@options);
 
     return $self->{socket};
 }
 
 sub log {
     my($self, %params) = @_;
 
 
     {
         if(($self->{silent_recovery} or $self->{defer_connection}) and 
            !defined $self->{socket}) {
             if(! $self->connect(%$self)) {
                 return undef;
             }
         }
   
         eval { $self->{socket}->send($params{message}); 
              };
 
         if($@) {
             warn "Send to " . ref($self) . " failed ($@), retrying once...";
             if($self->connect(%$self)) {
                 redo;
             }
             if($self->{silent_recovery}) {
                 return undef;
             }
             warn "Reconnect to $self->{PeerAddr}:$self->{PeerPort} " .
                  "failed: $!";
             return undef;
         }
     };
 
     return 1;
 }
 
 sub DESTROY {
     my($self) = @_;
 
     undef $self->{socket};
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/String.pm ###
 package Log::Log4perl::Appender::String;
 our @ISA = qw(Log::Log4perl::Appender);
 
 
 sub new {
     my $proto  = shift;
     my $class  = ref $proto || $proto;
     my %params = @_;
 
     my $self = {
         name      => "unknown name",
         string    => "",
         %params,
     };
 
     bless $self, $class;
 }
 
 sub log {   
     my $self = shift;
     my %params = @_;
 
     $self->{string} .= $params{message};
 }
 
 sub string {   
     my($self, $new) = @_;
 
     if(defined $new) {
         $self->{string} = $new;
     }
 
     return $self->{string};
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/Synchronized.pm ###
 
 package Log::Log4perl::Appender::Synchronized;
 
 use strict;
 use warnings;
 use Log::Log4perl::Util::Semaphore;
 
 our @ISA = qw(Log::Log4perl::Appender);
 
 our $CVSVERSION   = '$Revision: 1.12 $';
 our ($VERSION)    = ($CVSVERSION =~ /(\d+\.\d+)/);
 
 sub new {
     my($class, %options) = @_;
 
     my $self = {
         appender=> undef,
         key     => '_l4p',
         level   => 0,
         %options,
     };
 
     my @values = ();
     for my $param (qw(uid gid mode destroy key)) {
         push @values, $param, $self->{$param} if defined $self->{$param};
     }
 
     $self->{sem} = Log::Log4perl::Util::Semaphore->new(
         @values
     );
 
     push @{$options{l4p_depends_on}}, $self->{appender};
 
     push @{$options{l4p_post_config_subs}}, sub { $self->post_init() };
 
     bless $self, $class;
 }
 
 sub log {
     my($self, %params) = @_;
     
     $self->{sem}->semlock();
 
     $Log::Log4perl::caller_depth +=2;
     $self->{app}->SUPER::log(\%params, 
                              $params{log4p_category},
                              $params{log4p_level});
     $Log::Log4perl::caller_depth -=2;
 
     $self->{sem}->semunlock();
 }
 
 sub post_init {
     my($self) = @_;
 
     if(! exists $self->{appender}) {
        die "No appender defined for " . __PACKAGE__;
     }
 
     my $appenders = Log::Log4perl->appenders();
     my $appender = Log::Log4perl->appenders()->{$self->{appender}};
 
     if(! defined $appender) {
        die "Appender $self->{appender} not defined (yet) when " .
            __PACKAGE__ . " needed it";
     }
 
     $self->{app} = $appender;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/TestArrayBuffer.pm ###
 package Log::Log4perl::Appender::TestArrayBuffer;
 
 use base qw( Log::Log4perl::Appender::TestBuffer );
 
 sub log {   
     my $self = shift;
     my %params = @_;
 
     $self->{buffer} .= "[$params{level}]: " if $LOG_PRIORITY;
 
     if(ref($params{message}) eq "ARRAY") {
         $self->{buffer} .= "[" . join(',', @{$params{message}}) . "]";
     } else {
         $self->{buffer} .= $params{message};
     }
 }
 
 1;
 
### Log/Log4perl/Appender/TestBuffer.pm ###
 package Log::Log4perl::Appender::TestBuffer;
 our @ISA = qw(Log::Log4perl::Appender);
 
 
 our %POPULATION       = ();
 our $LOG_PRIORITY     = 0;
 our $DESTROY_MESSAGES = "";
 
 sub new {
     my $proto  = shift;
     my $class  = ref $proto || $proto;
     my %params = @_;
 
     my $self = {
         name      => "unknown name",
         %params,
     };
 
     bless $self, $class;
 
     $self->{stderr} = exists $params{stderr} ? $params{stderr} : 1;
     $self->{buffer} = "";
 
     $POPULATION{$self->{name}} = $self;
 
     return $self;
 }
 
 sub log {   
     my $self = shift;
     my %params = @_;
 
     if( !defined $params{level} ) {
         die "No level defined in log() call of " . __PACKAGE__;
     }
     $self->{buffer} .= "[$params{level}]: " if $LOG_PRIORITY;
     $self->{buffer} .= $params{message};
 }
 
 sub clear {
     my($self) = @_;
 
     $self->{buffer} = "";
 }
 
 sub buffer {   
     my($self, $new) = @_;
 
     if(defined $new) {
         $self->{buffer} = $new;
     }
 
     return $self->{buffer};
 }
 
 sub reset {   
     my($self) = @_;
 
     %POPULATION = ();
     $self->{buffer} = "";
 }
 
 sub DESTROY {   
     my($self) = @_;
 
     $DESTROY_MESSAGES .= __PACKAGE__ . " destroyed";
 
 }
 
 sub by_name {   
     my($self, $name) = @_;
 
 
     die "No name given"  unless defined $name;
 
     return $POPULATION{$name};
 
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Appender/TestFileCreeper.pm ###
 package Log::Log4perl::Appender::TestFileCreeper;
 
 use warnings;
 use strict;
 
 use Log::Log4perl::Appender::File;
 
 our @ISA = qw(Log::Log4perl::Appender::File);
 
 sub log {
     my($self, %params) = @_;
 
     my $fh = $self->{fh};
 
     for (split //, $params{message}) {
         print $fh $_;
         my $oldfh = select $self->{fh}; 
         $| = 1; 
         select $oldfh;
     }
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Catalyst.pm ###
 package Log::Log4perl::Catalyst;
 
 use strict;
 use Log::Log4perl qw(:levels);
 use Log::Log4perl::Logger;
 
 our $VERSION                  = $Log::Log4perl::VERSION;
 our $CATALYST_APPENDER_SUFFIX = "catalyst_buffer";
 our $LOG_LEVEL_ADJUSTMENT     = 1;
 
 init();
 
 sub init {
 
     my @levels = qw[ trace debug info warn error fatal ];
 
     Log::Log4perl->wrapper_register(__PACKAGE__);
 
     for my $level (@levels) {
         no strict 'refs';
 
         *{$level} = sub {
             my ( $self, @message ) = @_;
 
             local $Log::Log4perl::caller_depth =
                   $Log::Log4perl::caller_depth +
                      $LOG_LEVEL_ADJUSTMENT;
 
             my $logger = Log::Log4perl->get_logger();
             $logger->$level(@message);
             return 1;
         };
 
         *{"is_$level"} = sub {
             my ( $self, @message ) = @_;
 
             local $Log::Log4perl::caller_depth =
                   $Log::Log4perl::caller_depth +
                      $LOG_LEVEL_ADJUSTMENT;
 
             my $logger = Log::Log4perl->get_logger();
             my $func   = "is_" . $level;
             return $logger->$func;
         };
     }
 }
 
 sub new {
     my($class, $config, %options) = @_;
 
     my $self = {
         autoflush   => 0,
         abort       => 0,
         watch_delay => 0,
         %options,
     };
 
     if( !Log::Log4perl->initialized() ) {
         if( defined $config ) {
             if( $self->{watch_delay} ) {
                 Log::Log4perl::init_and_watch( $config, $self->{watch_delay} );
             } else {
                 Log::Log4perl::init( $config );
             }
         } else {
              Log::Log4perl->easy_init({
                  level  => $DEBUG,
                  layout => "[%d] [catalyst] [%p] %m%n",
              });
         }
     }
 
 
     if(! $options{autoflush} ) {
         for my $appender (values %Log::Log4perl::Logger::APPENDER_BY_NAME) {
             next if $appender->{name} =~ /_$CATALYST_APPENDER_SUFFIX$/;
 
 
             my $buf_app_name = "$appender->{name}_$CATALYST_APPENDER_SUFFIX";
 
             my $buf_app = Log::Log4perl::Appender->new(
                 'Log::Log4perl::Appender::Buffer',
                 name       => $buf_app_name,
                 appender   => $appender->{name},
                 trigger    => sub { 0 },    
             );
 
             Log::Log4perl->add_appender($buf_app);
             $buf_app->post_init();
             $buf_app->composite(1);
 
 
             foreach my $logger (
                            values %$Log::Log4perl::Logger::LOGGERS_BY_NAME){
                 if(defined $logger->remove_appender( $appender->{name}, 0, 1)) {
                     $logger->add_appender( $buf_app );
                 }
             }
         }
     }
 
     bless $self, $class;
 
     return $self;
 }
 
 sub _flush {
     my ($self) = @_;
 
     for my $appender (values %Log::Log4perl::Logger::APPENDER_BY_NAME) {
         next if $appender->{name} !~ /_$CATALYST_APPENDER_SUFFIX$/;
 
         if ($self->abort) {
             $appender->{appender}{buffer} = [];
         }
         else {
             $appender->flush();
         }
     }
 
     $self->abort(undef);
 }
 
 sub abort {
     my $self = shift;
 
     $self->{abort} = $_[0] if @_;
 
     return $self->{abort};
 }
 
 sub levels {
     return 0;
 }
 
 sub enable {
     return 0;
 }
 
 sub disable {
     return 0;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Config.pm ###
 package Log::Log4perl::Config;
 use 5.006;
 use strict;
 use warnings;
 
 use Log::Log4perl::Logger;
 use Log::Log4perl::Level;
 use Log::Log4perl::Config::PropertyConfigurator;
 use Log::Log4perl::JavaMap;
 use Log::Log4perl::Filter;
 use Log::Log4perl::Filter::Boolean;
 use Log::Log4perl::Config::Watch;
 
 use constant _INTERNAL_DEBUG => 0;
 
 our $CONFIG_FILE_READS       = 0;
 our $CONFIG_INTEGRITY_CHECK  = 1;
 our $CONFIG_INTEGRITY_ERROR  = undef;
 
 our $WATCHER;
 our $DEFAULT_WATCH_DELAY = 60; 
 our $OPTS = {};
 our $OLD_CONFIG;
 our $LOGGERS_DEFINED;
 our $UTF8 = 0;
 
 sub init {
     Log::Log4perl::Logger->reset();
 
     undef $WATCHER; 
 
     return _init(@_);
 }
 
 sub utf8 {
     my( $class, $flag ) = @_;
 
     $UTF8 = $flag if defined $flag;
 
     return $UTF8;
 }
 
 sub watcher {
     return $WATCHER;
 }
 
 sub init_and_watch {
     my ($class, $config, $delay, $opts) = @_;
 
     if(defined $WATCHER) {
         $config = $WATCHER->file();
         if(defined $Log::Log4perl::Config::Watch::SIGNAL_CAUGHT) {
             $delay  = $WATCHER->signal();
         } else {
             $delay  = $WATCHER->check_interval();
         }
     }
 
     print "init_and_watch ($config-$delay). Resetting.\n" if _INTERNAL_DEBUG;
 
     Log::Log4perl::Logger->reset();
 
     defined ($delay) or $delay = $DEFAULT_WATCH_DELAY;  
 
     if (ref $config) {
         die "Log4perl can only watch a file, not a string of " .
             "configuration information";
     }elsif ($config =~ m!^(https?|ftp|wais|gopher|file):!){
         die "Log4perl can only watch a file, not a url like $config";
     }
 
     if($delay =~ /\D/) {
         $WATCHER = Log::Log4perl::Config::Watch->new(
                           file         => $config,
                           signal       => $delay,
                           l4p_internal => 1,
                    );
     } else {
         $WATCHER = Log::Log4perl::Config::Watch->new(
                           file           => $config,
                           check_interval => $delay,
                           l4p_internal   => 1,
                    );
     }
 
     if(defined $opts) {
         die "Parameter $opts needs to be a hash ref" if ref($opts) ne "HASH";
         $OPTS = $opts;
     }
 
     eval { _init($class, $config); };
 
     if($@) {
         die "$@" unless defined $OLD_CONFIG;
         _init($class, undef, $OLD_CONFIG);
         warn "Loading new config failed, reverted to old one\n";
     }
 }
 
 sub _init {
     my($class, $config, $data) = @_;
 
     my %additivity = ();
 
     $LOGGERS_DEFINED = 0;
 
     print "Calling _init\n" if _INTERNAL_DEBUG;
 
     my %appenders_created = ();
 
     my @post_config_subs  = ();
 
 
     $data = config_read($config) unless defined $data;
     
     if(_INTERNAL_DEBUG) {
         require Data::Dumper;
         Data::Dumper->import();
         print Data::Dumper::Dumper($data);
     }
 
     my @loggers      = ();
     my %filter_names = ();
 
     my $system_wide_threshold;
 
     if(exists $data->{rootlogger} and 
        ! exists $data->{rootLogger}) {
          $data->{rootLogger} = $data->{rootlogger};
     }
 
     if(exists $data->{rootLogger}) {
         $LOGGERS_DEFINED++;
         push @loggers, ["", $data->{rootLogger}->{value}];
     }
         
     if(exists $data->{threshold}) {
         $system_wide_threshold = $data->{threshold}->{value};
     }
 
     if (exists $data->{oneMessagePerAppender}){
                     $Log::Log4perl::one_message_per_appender = 
                         $data->{oneMessagePerAppender}->{value};
     }
 
     if(exists $data->{utcDateTimes}) {
         require Log::Log4perl::DateFormat;
         $Log::Log4perl::DateFormat::GMTIME = !!$data->{utcDateTimes}->{value};
     }
 
     my %boolean_filters = ();
 
     for my $key (qw(logger category additivity PatternLayout filter)) {
 
         if(exists $data->{$key}) {
 
             for my $path (@{leaf_paths($data->{$key})}) {
 
                 print "Path before: @$path\n" if _INTERNAL_DEBUG;
 
                 my $value = boolean_to_perlish(pop @$path);
 
                 pop @$path; 
 
                 if($key eq "additivity") {
                     $additivity{join('.', @$path)} = $value;
 
                 }elsif ($key eq "PatternLayout"){
                     &add_global_cspec(@$path[-1], $value);
 
                 }elsif ($key eq "filter"){
                     print "Found entry @$path\n" if _INTERNAL_DEBUG;
                     $filter_names{@$path[0]}++;
                 } else {
 
                     if (ref($value) eq "ARRAY") {
                       die "Multiple definitions of logger ".join('.',@$path)." in log4perl config";
                     }
 
                     $LOGGERS_DEFINED++;
                     push @loggers, [join('.', @$path), $value];
                 }
             }
         }
     }
 
     for my $filter_name (keys %filter_names) {
 
         print "Checking filter $filter_name\n" if _INTERNAL_DEBUG;
 
         if($data->{filter}->{$filter_name}->{value} eq
            "Log::Log4perl::Filter::Boolean") {
             print "Boolean filter ($filter_name)\n" if _INTERNAL_DEBUG;
             $boolean_filters{$filter_name}++;
             next;
         }
 
         my $type = $data->{filter}->{$filter_name}->{value};
         if(my $code = compile_if_perl($type)) {
             $type = $code;
         }
         
         print "Filter $filter_name is of type $type\n" if _INTERNAL_DEBUG;
 
         my $filter;
 
         if(ref($type) eq "CODE") {
             $filter = Log::Log4perl::Filter->new($filter_name, $type);
         } else {
                 die "Filter class '$type' doesn't exist" unless
                      Log::Log4perl::Util::module_available($type);
                 eval "require $type" or die "Require of $type failed ($!)";
 
             $filter = $type->new(name => $filter_name,
                 map { $_ => $data->{filter}->{$filter_name}->{$_}->{value} } 
                 grep { $_ ne "value" } 
                 keys %{$data->{filter}->{$filter_name}});
         }
         $filter->register();
     }
 
     for my $name (keys %boolean_filters) {
         my $logic = $data->{filter}->{$name}->{logic}->{value};
         die "No logic defined for boolean filter $name" unless defined $logic;
         my $filter = Log::Log4perl::Filter::Boolean->new(
                          name  => $name, 
                          logic => $logic);
         $filter->register();
     }
 
     for (@loggers) {
         my($name, $value) = @$_;
 
         my $logger = Log::Log4perl::Logger->get_logger($name);
         my ($level, @appnames) = split /\s*,\s*/, $value;
 
         $logger->level(
             Log::Log4perl::Level::to_priority($level),
             'dont_reset_all');
 
         if(exists $additivity{$name}) {
             $logger->additivity($additivity{$name}, 1);
         }
 
         for my $appname (@appnames) {
 
             my $appender = create_appender_instance(
                 $data, $appname, \%appenders_created, \@post_config_subs,
                 $system_wide_threshold);
 
             $logger->add_appender($appender, 'dont_reset_all');
             set_appender_by_name($appname, $appender, \%appenders_created);
         }
     }
 
     for(@post_config_subs) {
         $_->();
     }
 
     Log::Log4perl::Logger::reset_all_output_methods();
 
     if($Log::Log4perl::Config::CONFIG_INTEGRITY_CHECK and
        !config_is_sane()) {
         warn "Log::Log4perl configuration looks suspicious: ",
              "$CONFIG_INTEGRITY_ERROR";
     }
 
     $OLD_CONFIG = $data;
 
     $Log::Log4perl::Logger::INITIALIZED = 1;
 }
 
 sub config_is_sane {
     if(! $LOGGERS_DEFINED) {
         $CONFIG_INTEGRITY_ERROR = "No loggers defined";
         return 0;
     }    
 
     if(scalar keys %Log::Log4perl::Logger::APPENDER_BY_NAME == 0) {
         $CONFIG_INTEGRITY_ERROR = "No appenders defined";
         return 0;
     }
 
     return 1;
 }
 
 sub create_appender_instance {
     my($data, $appname, $appenders_created, $post_config_subs,
        $system_wide_threshold) = @_;
 
     my $appenderclass = get_appender_by_name(
             $data, $appname, $appenders_created);
 
     print "appenderclass=$appenderclass\n" if _INTERNAL_DEBUG;
 
     my $appender;
 
     if (ref $appenderclass) {
         $appender = $appenderclass;
     } else {
         die "ERROR: you didn't tell me how to " .
             "implement your appender '$appname'"
                 unless $appenderclass;
 
         if (Log::Log4perl::JavaMap::translate($appenderclass)){
             print "Trying to map Java $appname\n" if _INTERNAL_DEBUG;
             $appender = Log::Log4perl::JavaMap::get($appname, 
                                         $data->{appender}->{$appname});
 
         }else{
             my @params = grep { $_ ne "layout" and
                                 $_ ne "value"
                               } keys %{$data->{appender}->{$appname}};
     
             my %param = ();
             foreach my $pname (@params){
                 if (exists $data->{appender}{$appname}
                                   {$pname}{value}      ) {
                     $param{$pname} = $data->{appender}{$appname}
                                             {$pname}{value};
                 }else{
                     $param{$pname} = {map {$_ => $data->{appender}
                                                         {$appname}
                                                         {$pname}
                                                         {$_}
                                                         {value}} 
                                      keys %{$data->{appender}
                                                    {$appname}
                                                    {$pname}}
                                      };
                 }
     
             }
 
             my $depends_on = [];
     
             $appender = Log::Log4perl::Appender->new(
                 $appenderclass, 
                 name                 => $appname,
                 l4p_post_config_subs => $post_config_subs,
                 l4p_depends_on       => $depends_on,
                 %param,
             ); 
     
             for my $dependency (@$depends_on) {
                 $appender->composite(1);
                 next if exists $appenders_created->{$appname};
                 my $app = create_appender_instance($data, $dependency, 
                              $appenders_created,
                              $post_config_subs);
 
                 $
                 Log::Log4perl::Logger::APPENDER_BY_NAME{$dependency} = $app;
             }
         }
     }
 
     add_layout_by_name($data, $appender, $appname) unless
         $appender->composite();
 
     my $threshold = 
        $data->{appender}->{$appname}->{Threshold}->{value};
 
     if(defined $system_wide_threshold and
        !defined $threshold) {
         $threshold = $system_wide_threshold;
     }
 
     if(defined $threshold) {
         $appender->threshold($
             Log::Log4perl::Level::PRIORITY{$threshold});
     }
 
     my $filtername = 
        $data->{appender}->{$appname}->{Filter}->{value};
     if(defined $filtername) {
         my $filter = Log::Log4perl::Filter::by_name($filtername);
         die "Filter $filtername doesn't exist" unless defined $filter;
         $appender->filter($filter);
     }
 
     if(defined $system_wide_threshold and
        defined $threshold and
        $
         Log::Log4perl::Level::PRIORITY{$system_wide_threshold} > 
        $
          Log::Log4perl::Level::PRIORITY{$threshold}
       ) {
         $appender->threshold($
             Log::Log4perl::Level::PRIORITY{$system_wide_threshold});
     }
 
     if(exists $data->{appender}->{$appname}->{threshold}) {
         die "invalid keyword 'threshold' - perhaps you meant 'Threshold'?";
     }
 
     return $appender;
 }
 
 sub add_layout_by_name {
     my($data, $appender, $appender_name) = @_;
 
     my $layout_class = $data->{appender}->{$appender_name}->{layout}->{value};
 
     die "Layout not specified for appender $appender_name" unless $layout_class;
 
     $layout_class =~ s/org.apache.log4j./Log::Log4perl::Layout::/;
 
     if(!Log::Log4perl::Util::module_available($layout_class)) {
         if(Log::Log4perl::Util::module_available(
            "Log::Log4perl::Layout::$layout_class")) {
             $layout_class = "Log::Log4perl::Layout::$layout_class";
         } else {
             die "ERROR: trying to set layout for $appender_name to " .
                 "'$layout_class' failed";
         }
     }
 
     eval "require $layout_class" or 
         die "Require to $layout_class failed ($!)";
 
     $appender->layout($layout_class->new(
         $data->{appender}->{$appender_name}->{layout},
         ));
 }
 
 sub get_appender_by_name {
     my($data, $name, $appenders_created) = @_;
 
     if (exists $appenders_created->{$name}) {
         return $appenders_created->{$name};
     } else {
         return $data->{appender}->{$name}->{value};
     }
 }
 
 sub set_appender_by_name {
     my($appname, $appender, $appenders_created) = @_;
 
     $appenders_created->{$appname} ||= $appender;
 }
 
 sub add_global_cspec {
     my ($letter, $perlcode) = @_;
 
     die "error: only single letters allowed in log4j.PatternLayout.cspec.$letter"
         unless ($letter =~ /^[a-zA-Z]$/);
 
     Log::Log4perl::Layout::PatternLayout::add_global_cspec($letter, $perlcode);
 }
 
 my $LWP_USER_AGENT;
 sub set_LWP_UserAgent
 {
     $LWP_USER_AGENT = shift;
 }
 
 
 sub config_read {
     my($config) = @_;
 
     die "Configuration not defined" unless defined $config;
 
     my @text;
     my $parser;
 
     $CONFIG_FILE_READS++;  
 
     my $base_configurator = Log::Log4perl::Config::BaseConfigurator->new(
         utf8 => $UTF8,
     );
 
     my $data = {};
 
     if (ref($config) eq 'HASH') {   
         print "Reading config from hash\n" if _INTERNAL_DEBUG;
         @text = ();
         for my $key ( keys %$config ) {
             if( ref( $config->{$key} ) eq "CODE" ) {
                 $config->{$key} = $config->{$key}->();
             }
             push @text, $key . '=' . $config->{$key} . "\n";
         }
     } elsif (ref $config eq 'SCALAR') {
         print "Reading config from scalar\n" if _INTERNAL_DEBUG;
         @text = split(/\n/,$$config);
 
     } elsif (ref $config eq 'GLOB' or 
              ref $config eq 'IO::File') {
         print "Reading config from file handle\n" if _INTERNAL_DEBUG;
         @text = @{ $base_configurator->file_h_read( $config ) };
 
     } elsif (ref $config) {
         print "Reading config from parser object\n" if _INTERNAL_DEBUG;
         $data = $config->parse();
         return $data;
 
     } elsif ($config =~ m|^ldap://|){
        if(! Log::Log4perl::Util::module_available("Net::LDAP")) {
            die "Log4perl: missing Net::LDAP needed to parse LDAP urls\n$@\n";
        }
 
        require Net::LDAP;
        require Log::Log4perl::Config::LDAPConfigurator;
 
        return Log::Log4perl::Config::LDAPConfigurator->new->parse($config);
 
     } else {
 
         if ($config =~ /^(https?|ftp|wais|gopher|file):/){
             my ($result, $ua);
     
             die "LWP::UserAgent not available" unless
                 Log::Log4perl::Util::module_available("LWP::UserAgent");
 
             require LWP::UserAgent;
             unless (defined $LWP_USER_AGENT) {
                 $LWP_USER_AGENT = LWP::UserAgent->new;
     
                 $LWP_USER_AGENT->env_proxy;
             }
             $ua = $LWP_USER_AGENT;
 
             my $req = new HTTP::Request GET => $config;
             my $res = $ua->request($req);
 
             if ($res->is_success) {
                 @text = split(/\n/, $res->content);
             } else {
                 die "Log4perl couln't get $config, ".
                      $res->message." ";
             }
         } else {
             print "Reading config from file '$config'\n" if _INTERNAL_DEBUG;
             print "Reading ", -s $config, " bytes.\n" if _INTERNAL_DEBUG;
             $base_configurator->file( $config );
             @text = @{ $base_configurator->text() };
         }
     }
     
     print "Reading $config: [@text]\n" if _INTERNAL_DEBUG;
 
     if(! grep /\S/, @text) {
         return $data;
     }
 
     if ($text[0] =~ /^<\?xml /) {
 
         die "XML::DOM not available" unless
                 Log::Log4perl::Util::module_available("XML::DOM");
 
         require XML::DOM; 
         require Log::Log4perl::Config::DOMConfigurator;
 
         XML::DOM->VERSION($Log::Log4perl::DOM_VERSION_REQUIRED);
         $parser = Log::Log4perl::Config::DOMConfigurator->new();
         $data = $parser->parse(\@text);
     } else {
         $parser = Log::Log4perl::Config::PropertyConfigurator->new();
         $data = $parser->parse(\@text);
     }
 
     $data = $parser->parse_post_process( $data, leaf_paths($data) );
 
     return $data;
 }
 
 sub unlog4j {
     my ($string) = @_;
 
     $string =~ s#^org\.apache\.##;
     $string =~ s#^log4j\.##;
     $string =~ s#^l4p\.##;
     $string =~ s#^log4perl\.##i;
 
     $string =~ s#\.#::#g;
 
     return $string;
 }
 
 sub leaf_paths {
     my ($root) = @_;
 
     my @stack  = ();
     my @result = ();
 
     push @stack, [$root, []];  
     
     while(@stack) {
         my $item = pop @stack;
 
         my($node, $path) = @$item;
 
         if(ref($node) eq "HASH") { 
             for(keys %$node) {
                 push @stack, [$node->{$_}, [@$path, $_]];
             }
         } else {
             push @result, [@$path, $node];
         }
     }
     return \@result;
 }
 
 sub leaf_path_to_hash {
     my($leaf_path, $data) = @_;
 
     my $ref = \$data;
 
     for my $part ( @$leaf_path[0..$#$leaf_path-1] ) {
         $ref = \$$ref->{ $part };
     }
 
     return $ref;
 }
 
 sub eval_if_perl {
     my($value) = @_;
 
     if(my $cref = compile_if_perl($value)) {
         return $cref->();
     }
 
     return $value;
 }
 
 sub compile_if_perl {
     my($value) = @_;
 
     if($value =~ /^\s*sub\s*{/ ) {
         my $mask;
         unless( Log::Log4perl::Config->allow_code() ) {
             die "\$Log::Log4perl::Config->allow_code() setting " .
                 "prohibits Perl code in config file";
         }
         if( defined( $mask = Log::Log4perl::Config->allowed_code_ops() ) ) {
             return compile_in_safe_cpt($value, $mask );
         }
         elsif( $mask = Log::Log4perl::Config->allowed_code_ops_convenience_map(
                              Log::Log4perl::Config->allow_code()
                           ) ) {
             return compile_in_safe_cpt($value, $mask );
         }
         elsif( Log::Log4perl::Config->allow_code() == 1 ) {
 
             my $cref = eval "package main; $value" or 
                 die "Can't evaluate '$value' ($@)";
             return $cref;
         }
         else {
             die "Invalid value for \$Log::Log4perl::Config->allow_code(): '".
                 Log::Log4perl::Config->allow_code() . "'";
         }
     }
 
     return undef;
 }
 
 sub compile_in_safe_cpt {
     my($value, $allowed_ops) = @_;
 
     require Safe;
     my $safe = Safe->new();
     $safe->permit_only( @{ $allowed_ops } );
  
     for( keys %{ Log::Log4perl::Config->vars_shared_with_safe_compartment() } ) {
         my $toshare = Log::Log4perl::Config->vars_shared_with_safe_compartment($_);
         $safe->share_from( $_, $toshare )
             or die "Can't share @{ $toshare } with Safe compartment";
     }
     
     my $cref = $safe->reval("package main; $value") or
         die "Can't evaluate '$value' in Safe compartment ($@)";
     return $cref;
     
 }
 
 sub boolean_to_perlish {
     my($value) = @_;
 
     $value = 1 if $value =~ /^true$/i;
     $value = 0 if $value =~ /^false$/i;
 
     return $value;
 }
 
 sub vars_shared_with_safe_compartment {
     my($class, @args) = @_;
 
     if(defined $class and $class ne __PACKAGE__) {
         unshift @args, $class;
     }
    
     if(@args == 1 && ref $args[0] eq 'HASH' ) {
         %Log::Log4perl::VARS_SHARED_WITH_SAFE_COMPARTMENT = %{$args[0]};
     }
     elsif( @args == 1 ) {
         return $Log::Log4perl::VARS_SHARED_WITH_SAFE_COMPARTMENT{
                $args[0]};
     }
     elsif( @args == 2 ) {
         $Log::Log4perl::VARS_SHARED_WITH_SAFE_COMPARTMENT{
            $args[0]} = $args[1];
     }
 
     return wantarray ? %Log::Log4perl::VARS_SHARED_WITH_SAFE_COMPARTMENT
                      : \%Log::Log4perl::VARS_SHARED_WITH_SAFE_COMPARTMENT;
     
 }
 
 sub allowed_code_ops {
     my($class, @args) = @_;
 
     if(defined $class and $class ne __PACKAGE__) {
         unshift @args, $class;
     }
    
     if(@args) {
         @Log::Log4perl::ALLOWED_CODE_OPS_IN_CONFIG_FILE = @args;
     }
     else {
         unless( @Log::Log4perl::ALLOWED_CODE_OPS_IN_CONFIG_FILE ) {
             return;
         }
     }
 
     return wantarray ? @Log::Log4perl::ALLOWED_CODE_OPS_IN_CONFIG_FILE
                      : \@Log::Log4perl::ALLOWED_CODE_OPS_IN_CONFIG_FILE;
 }
 
 sub allowed_code_ops_convenience_map {
     my($class, @args) = @_;
 
     if(defined $class and $class ne __PACKAGE__) {
         unshift @args, $class;
     }
 
     if( @args == 1 && ref $args[0] eq 'HASH' ) {
         %Log::Log4perl::ALLOWED_CODE_OPS = %{$args[0]};
     }
     elsif( @args == 1 ) {
         return $Log::Log4perl::ALLOWED_CODE_OPS{
                    $args[0]};
     }
     elsif( @args == 2 ) {
         if( ref $args[1] ne 'ARRAY' ) {
             die "invalid mask (not an array ref) for convenience name '$args[0]'";
         }
         $Log::Log4perl::ALLOWED_CODE_OPS{
             $args[0]} = $args[1];
     }
 
     return wantarray ? %Log::Log4perl::ALLOWED_CODE_OPS
                      : \%Log::Log4perl::ALLOWED_CODE_OPS
 }
 
 sub allow_code {
     my($class, @args) = @_;
 
     if(defined $class and $class ne __PACKAGE__) {
         unshift @args, $class;
     }
    
     if(@args) {
         $Log::Log4perl::ALLOW_CODE_IN_CONFIG_FILE = 
             $args[0];
     }
 
     return $Log::Log4perl::ALLOW_CODE_IN_CONFIG_FILE;
 }
 
 sub var_subst {
     my($varname, $subst_hash) = @_;
 
     $varname =~ s/\s+//g;
 
     if(exists $subst_hash->{$varname}) {
         print "Replacing variable: '$varname' => '$subst_hash->{$varname}'\n" 
             if _INTERNAL_DEBUG;
         return $subst_hash->{$varname};
 
     } elsif(exists $ENV{$varname}) {
         print "Replacing ENV variable: '$varname' => '$ENV{$varname}'\n" 
             if _INTERNAL_DEBUG;
         return $ENV{$varname};
 
     }
 
     die "Undefined Variable '$varname'";
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Config/BaseConfigurator.pm ###
 package Log::Log4perl::Config::BaseConfigurator;
 
 use warnings;
 use strict;
 use constant _INTERNAL_DEBUG => 0;
 
 *eval_if_perl      = \&Log::Log4perl::Config::eval_if_perl;
 *compile_if_perl   = \&Log::Log4perl::Config::compile_if_perl;
 *leaf_path_to_hash = \&Log::Log4perl::Config::leaf_path_to_hash;
 
 sub new {
     my($class, %options) = @_;
 
     my $self = { 
         utf8 => 0,
         %options,
     };
 
     bless $self, $class;
 
     $self->file($self->{file}) if exists $self->{file};
     $self->text($self->{text}) if exists $self->{text};
 
     return $self;
 }
 
 sub text {
     my($self, $text) = @_;
 
     if(defined $text) {
         if(ref $text eq "ARRAY") {
             $self->{text} = $text;
         } else {
             $self->{text} = [split "\n", $text];
         }
     }
 
     return $self->{text};
 }
 
 sub file {
     my($self, $filename) = @_;
 
     open my $fh, "$filename" or die "Cannot open $filename ($!)";
 
     if( $self->{ utf8 } ) {
         binmode $fh, ":utf8";
     }
 
     $self->file_h_read( $fh );
     close $fh;
 }
 
 sub file_h_read {
     my($self, $fh) = @_;
 
     local $/ = "\n";
 
     $self->{text} = [<$fh>];
 }
 
 sub parse {
     die __PACKAGE__ . "::parse() is a virtual method. " .
         "It must be implemented " .
         "in a derived class (currently: ", ref(shift), ")";
 }
 
 sub parse_post_process {
     my($self, $data, $leaf_paths) = @_;
     
 
     for my $path ( @{ Log::Log4perl::Config::leaf_paths( $data )} ) {
 
         print "path=@$path\n" if _INTERNAL_DEBUG;
 
         if(0) {
         } elsif( 
             $path->[0] eq "appender" and
             $path->[2] eq "trigger"
           ) {
             my $ref = leaf_path_to_hash( $path, $data );
             my $code = compile_if_perl( $$ref );
 
             if(_INTERNAL_DEBUG) {
                 if($code) {
                     print "Code compiled: $$ref\n";
                 } else {
                     print "Not compiled: $$ref\n";
                 }
             }
 
             $$ref = $code if defined $code;
         } elsif (
             $path->[0] eq "filter"
           ) {
         } elsif (
             $path->[0] eq "appender" and
             $path->[2] eq "warp_message"
           ) {
         } elsif (
             $path->[0] eq "appender" and
             $path->[3] eq "cspec" or
             $path->[1] eq "cspec"
           ) {
         } else {
             my $ref = leaf_path_to_hash( $path, $data );
 
             if(_INTERNAL_DEBUG) {
                 print "Calling eval_if_perl on $$ref\n";
             }
 
             $$ref = eval_if_perl( $$ref );
         }
     }
 
     return $data;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Config/DOMConfigurator.pm ###
 package Log::Log4perl::Config::DOMConfigurator;
 use Log::Log4perl::Config::BaseConfigurator;
 
 our @ISA = qw(Log::Log4perl::Config::BaseConfigurator);
 
 
 use XML::DOM;
 use Log::Log4perl::Level;
 use strict;
 
 use constant _INTERNAL_DEBUG => 0;
 
 our $VERSION = 0.03;
 
 our $APPENDER_TAG = qr/^((log4j|log4perl):)?appender$/;
 
 our $FILTER_TAG = qr/^(log4perl:)?filter$/;
 our $FILTER_REF_TAG = qr/^(log4perl:)?filter-ref$/;
 
 our $PARSER_CLASS = 'XML::DOM::Parser';
 
 our $LOG4J_PREFIX = 'log4j';
 our $LOG4PERL_PREFIX = 'log4perl';
     
 
 *eval_if_perl = \&Log::Log4perl::Config::eval_if_perl;
 *unlog4j      = \&Log::Log4perl::Config::unlog4j;
 
 
 sub parse {
     my($self, $newtext) = @_;
 
     $self->text($newtext) if defined $newtext;
     my $text = $self->{text};
 
     my $parser = $PARSER_CLASS->new;
     my $doc = $parser->parse (join('',@$text));
 
 
     my $l4p_tree = {};
     
     my $config = $doc->getElementsByTagName("$LOG4J_PREFIX:configuration")->item(0)||
                  $doc->getElementsByTagName("$LOG4PERL_PREFIX:configuration")->item(0);
 
     my $threshold = uc(subst($config->getAttribute('threshold')));
     if ($threshold) {
         $l4p_tree->{threshold}{value} = $threshold;
     }
 
     if (subst($config->getAttribute('oneMessagePerAppender')) eq 'true') {
         $l4p_tree->{oneMessagePerAppender}{value} = 1;
     }
 
     for my $kid ($config->getChildNodes){
 
         next unless $kid->getNodeType == ELEMENT_NODE;
 
         my $tag_name = $kid->getTagName;
 
         if ($tag_name =~ $APPENDER_TAG) {
             &parse_appender($l4p_tree, $kid);
 
         }elsif ($tag_name eq 'category' || $tag_name eq 'logger'){
             &parse_category($l4p_tree, $kid);
 
         }elsif ($tag_name eq 'root'){
             &parse_root($l4p_tree, $kid);
 
         }elsif ($tag_name =~ $FILTER_TAG){
             &parse_l4p_filter($l4p_tree, $kid);
 
         }elsif ($tag_name eq 'renderer'){
             warn "Log4perl: ignoring renderer tag in config, unimplemented";
          
         }elsif ($tag_name eq 'PatternLayout'){
             &parse_patternlayout($l4p_tree, $kid);
         }
     }
     $doc->dispose;
 
     return $l4p_tree;
 }
 
 sub parse_patternlayout {
     my ($l4p_tree, $node) = @_;
 
     my $l4p_branch = {};
 
     for my $child ($node->getChildNodes) {
         next unless $child->getNodeType == ELEMENT_NODE;
 
         my $name = subst($child->getAttribute('name'));
         my $value;
 
         foreach my $grandkid ($child->getChildNodes){
             if ($grandkid->getNodeType == TEXT_NODE) {
                 $value .= $grandkid->getData;
             }
         }
         $value =~ s/^ +//;  
         $value =~ s/ +$//;
         $l4p_branch->{$name}{value} = subst($value);
     }
     $l4p_tree->{PatternLayout}{cspec} = $l4p_branch;
 }
 
 
 sub parse_root {
     my ($l4p_tree, $node) = @_;
 
     my $l4p_branch = {};
 
     &parse_children_of_logger_element($l4p_branch, $node);
 
     $l4p_tree->{category}{value} = $l4p_branch->{value};
 
 }
 
 
 sub parse_l4p_filter {
     my ($l4p_tree, $node) = @_;
 
     my $l4p_branch = {};
 
     my $name = subst($node->getAttribute('name'));
 
     my $class = subst($node->getAttribute('class'));
     my $value = subst($node->getAttribute('value'));
 
     if ($class && $value) {
         die "Log4perl: only one of class or value allowed, not both, "
             ."in XMLConfig filter '$name'";
     }elsif ($class || $value){
         $l4p_branch->{value} = ($value || $class);
 
     }
 
     for my $child ($node->getChildNodes) {
 
         if ($child->getNodeType == ELEMENT_NODE){
 
             my $tag_name = $child->getTagName();
 
             if ($tag_name =~ /^(param|param-nested|param-text)$/) {
                 &parse_any_param($l4p_branch, $child);
             }
         }elsif ($child->getNodeType == TEXT_NODE){
             my $text = $child->getData;
             next unless $text =~ /\S/;
             if ($class && $value) {
                 die "Log4perl: only one of class, value or PCDATA allowed, "
                     ."in XMLConfig filter '$name'";
             }
             $l4p_branch->{value} .= subst($text); 
         }
     }
 
     $l4p_tree->{filter}{$name} = $l4p_branch;
 }
 
    
 sub parse_category {
     my ($l4p_tree, $node) = @_;
 
     my $name = subst($node->getAttribute('name'));
 
     $l4p_tree->{category} ||= {};
  
     my $ptr = $l4p_tree->{category};
 
     for my $part (split /\.|::/, $name) {
         $ptr->{$part} = {} unless exists $ptr->{$part};
         $ptr = $ptr->{$part};
     }
 
     my $l4p_branch = $ptr;
 
     my $class = subst($node->getAttribute('class'));
     $class                       && 
        $class ne 'Log::Log4perl' &&
        $class ne 'org.apache.log4j.Logger' &&
        warn "setting category $name to class $class ignored, only Log::Log4perl implemented";
 
     my $additivity = subst(subst($node->getAttribute('additivity')));
     if (length $additivity > 0) {
         $l4p_tree->{additivity} ||= {};
         my $add_ptr = $l4p_tree->{additivity};
 
         for my $part (split /\.|::/, $name) {
             $add_ptr->{$part} = {} unless exists $add_ptr->{$part};
             $add_ptr = $add_ptr->{$part};
         }
         $add_ptr->{value} = &parse_boolean($additivity);
     }
 
     &parse_children_of_logger_element($l4p_branch, $node);
 }
 
 sub parse_children_of_logger_element {
     my ($l4p_branch, $node) = @_;
 
     my (@appenders, $priority);
 
     for my $child ($node->getChildNodes) {
         next unless $child->getNodeType == ELEMENT_NODE;
             
         my $tag_name = $child->getTagName();
 
         if ($tag_name eq 'param') {
             my $name = subst($child->getAttribute('name'));
             my $value = subst($child->getAttribute('value'));
             if ($value =~ /^(all|debug|info|warn|error|fatal|off|null)^/) {
                 $value = uc $value;
             }
             $l4p_branch->{$name} = {value => $value};
         
         }elsif ($tag_name eq 'appender-ref'){
             push @appenders, subst($child->getAttribute('ref'));
             
         }elsif ($tag_name eq 'level' || $tag_name eq 'priority'){
             $priority = &parse_level($child);
         }
     }
     $l4p_branch->{value} = $priority.', '.join(',', @appenders);
     
     return;
 }
 
 
 sub parse_level {
     my $node = shift;
 
     my $level = uc (subst($node->getAttribute('value')));
 
     die "Log4perl: invalid level in config: $level"
         unless Log::Log4perl::Level::is_valid($level);
 
     return $level;
 }
 
 
 
 sub parse_appender {
     my ($l4p_tree, $node) = @_;
 
     my $name = subst($node->getAttribute("name"));
 
     my $l4p_branch = {};
 
     my $class = subst($node->getAttribute("class"));
 
     $l4p_branch->{value} = $class;
 
     print "looking at $name----------------------\n"  if _INTERNAL_DEBUG;
 
     for my $child ($node->getChildNodes) {
         next unless $child->getNodeType == ELEMENT_NODE;
 
         my $tag_name = $child->getTagName();
 
         my $name = unlog4j(subst($child->getAttribute('name')));
 
         if ($tag_name =~ /^(param|param-nested|param-text)$/) {
 
             &parse_any_param($l4p_branch, $child);
 
             my $value;
 
         }elsif ($tag_name =~ /($LOG4PERL_PREFIX:)?layout/){
             $l4p_branch->{layout} = parse_layout($child);
 
         }elsif ($tag_name =~  $FILTER_TAG){
             $l4p_branch->{Filter} = parse_filter($child);
 
         }elsif ($tag_name =~ $FILTER_REF_TAG){
             $l4p_branch->{Filter} = parse_filter_ref($child);
 
         }elsif ($tag_name eq 'errorHandler'){
             die "errorHandlers not supported yet";
 
         }elsif ($tag_name eq 'appender-ref'){
             die "Log4perl: in config file, <appender-ref> tag is unsupported in <appender>";
         }else{
             die "Log4perl: in config file, <$tag_name> is unsupported\n";
         }
     }
     $l4p_tree->{appender}{$name} = $l4p_branch;
 }
 
 sub parse_any_param {
     my ($l4p_branch, $child) = @_;
 
     my $tag_name = $child->getTagName();
     my $name = subst($child->getAttribute('name'));
     my $value;
 
     print "parse_any_param: <$tag_name name=$name\n" if _INTERNAL_DEBUG;
 
     if ($tag_name eq 'param-nested'){
         
         if ($l4p_branch->{$name}){
             die "Log4perl: in config file, multiple param-nested tags for $name not supported";
         }
         $l4p_branch->{$name} = &parse_param_nested($child); 
 
         return;
 
     }elsif ($tag_name eq 'param') {
 
          $value = subst($child->getAttribute('value'));
 
          print "parse_param_nested: got param $name = $value\n"  
              if _INTERNAL_DEBUG;
         
          if ($value =~ /^(all|debug|info|warn|error|fatal|off|null)$/) {
              $value = uc $value;
          }
 
          if ($name !~ /warp_message|filter/ &&
             $child->getParentNode->getAttribute('name') ne 'cspec') {
             $value = eval_if_perl($value);
          }
     }elsif ($tag_name eq 'param-text'){
 
         foreach my $grandkid ($child->getChildNodes){
             if ($grandkid->getNodeType == TEXT_NODE) {
                 $value .= $grandkid->getData;
             }
         }
         if ($name !~ /warp_message|filter/ &&
             $child->getParentNode->getAttribute('name') ne 'cspec') {
             $value = eval_if_perl($value);
         }
     }
 
     $value = subst($value);
 
      if (defined $l4p_branch->{$name}{value} ) {
          if (ref $l4p_branch->{$name}{value} ne 'ARRAY'){
              my $temp = $l4p_branch->{$name}{value};
              $l4p_branch->{$name}{value} = [$temp];
          }
          push @{$l4p_branch->{$name}{value}}, $value;
      }else{
          $l4p_branch->{$name} = {value => $value};
      }
 }
 
 sub parse_param_nested {
     my ($node) = shift;
 
     my $l4p_branch = {};
 
     for my $child ($node->getChildNodes) {
         next unless $child->getNodeType == ELEMENT_NODE;
 
         my $tag_name = $child->getTagName();
 
         if ($tag_name =~ /^param|param-nested|param-text$/) {
             &parse_any_param($l4p_branch, $child);
         }
     }
 
     return $l4p_branch;
 }
 
 sub parse_filter {
     my $node = shift;
 
     my $filter_tree = {};
 
     my $class_name = subst($node->getAttribute('class'));
 
     $filter_tree->{value} = $class_name;
 
     print "\tparsing filter on class $class_name\n"  if _INTERNAL_DEBUG;  
 
     for my $child ($node->getChildNodes) {
         next unless $child->getNodeType == ELEMENT_NODE;
 
         my $tag_name = $child->getTagName();
 
         if ($tag_name =~ 'param|param-nested|param-text') {
             &parse_any_param($filter_tree, $child);
         
         }else{
             die "Log4perl: don't know what to do with a ".$child->getTagName()
                 ."inside a filter element";
         }
     }
     return $filter_tree;
 }
 
 sub parse_filter_ref {
     my $node = shift;
 
     my $filter_tree = {};
 
     my $filter_id = subst($node->getAttribute('id'));
 
     $filter_tree->{value} = $filter_id;
 
     return $filter_tree;
 }
 
 
 
 sub parse_layout {
     my $node = shift;
 
     my $layout_tree = {};
 
     my $class_name = subst($node->getAttribute('class'));
     
     $layout_tree->{value} = $class_name;
     print "\tparsing layout $class_name\n"  if _INTERNAL_DEBUG;  
     for my $child ($node->getChildNodes) {
         next unless $child->getNodeType == ELEMENT_NODE;
         if ($child->getTagName() eq 'param') {
             my $name = subst($child->getAttribute('name'));
             my $value = subst($child->getAttribute('value'));
             if ($value =~ /^(all|debug|info|warn|error|fatal|off|null)$/) {
                 $value = uc $value;
             }
             print "\tparse_layout: got param $name = $value\n"
                 if _INTERNAL_DEBUG;
             $layout_tree->{$name}{value} = $value;  
 
         }elsif ($child->getTagName() eq 'cspec') {
             my $name = subst($child->getAttribute('name'));
             my $value;
             foreach my $grandkid ($child->getChildNodes){
                 if ($grandkid->getNodeType == TEXT_NODE) {
                     $value .= $grandkid->getData;
                 }
             }
             $value =~ s/^ +//;
             $value =~ s/ +$//;
             $layout_tree->{cspec}{$name}{value} = subst($value);  
         }
     }
     return $layout_tree;
 }
 
 sub parse_boolean {
     my $a = shift;
 
     if ($a eq '0' || lc $a eq 'false') {
         return '0';
     }elsif ($a eq '1' || lc $a eq 'true'){
         return '1';
     }else{
         return $a; 
     }
 }
 
 
 sub subst {
     my $val = shift;
 
     $val =~ s/\$\{(.*?)}/
                       Log::Log4perl::Config::var_subst($1, {})/gex;
     return $val;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Config/PropertyConfigurator.pm ###
 package Log::Log4perl::Config::PropertyConfigurator;
 use Log::Log4perl::Config::BaseConfigurator;
 
 use warnings;
 use strict;
 
 our @ISA = qw(Log::Log4perl::Config::BaseConfigurator);
 
 our %NOT_A_MULT_VALUE = map { $_ => 1 }
     qw(conversionpattern);
 
 *eval_if_perl = \&Log::Log4perl::Config::eval_if_perl;
 *compile_if_perl = \&Log::Log4perl::Config::compile_if_perl;
 *unlog4j      = \&Log::Log4perl::Config::unlog4j;
 
 use constant _INTERNAL_DEBUG => 0;
 
 our $COMMENT_REGEX = qr/[#;!]/;
 
 sub parse {
     my($self, $newtext) = @_;
 
     $self->text($newtext) if defined $newtext;
 
     my $text = $self->{text};
 
     die "Config parser has nothing to parse" unless defined $text;
 
     my $data = {};
     my %var_subst = ();
 
     while (@$text) {
         local $_ = shift @$text;
         s/^\s*$COMMENT_REGEX.*//;
         next unless /\S/;
     
         my @parts = ();
 
         while (/(.+?)\\\s*$/) {
             my $prev = $1;
             my $next = shift(@$text);
             $next =~ s/^ +//g;  
             $next =~ s/^$COMMENT_REGEX.*//;
             $_ = $prev. $next;
             chomp;
         }
 
         if(my($key, $val) = /(\S+?)\s*=\s*(.*)/) {
 
             my $key_org = $key;
 
             $val =~ s/\s+$//;
 
             $var_subst{$key} = $val;
 
             $val =~ s/\$\{(.*?)\}/
                       Log::Log4perl::Config::var_subst($1, \%var_subst)/gex;
 
             $key = unlog4j($key);
 
             my $how_deep = 0;
             my $ptr = $data;
             for my $part (split /\.|::/, $key) {
                 push @parts, $part;
                 $ptr->{$part} = {} unless exists $ptr->{$part};
                 $ptr = $ptr->{$part};
                 ++$how_deep;
             }
 
             if (exists $ptr->{value} && 
                 $how_deep > 2 &&
                 defined $parts[0] && lc($parts[0]) eq "appender" && 
                 defined $parts[2] && ! exists $NOT_A_MULT_VALUE{lc($parts[2])}
                ) {
                 if (ref ($ptr->{value}) ne 'ARRAY') {
                     my $temp = $ptr->{value};
                     $ptr->{value} = [];
                     push (@{$ptr->{value}}, $temp);
                 }
                 push (@{$ptr->{value}}, $val);
             }else{
                 if(defined $ptr->{value}) {
                     if(! $Log::Log4perl::Logger::NO_STRICT) {
                         die "$key_org redefined";
                     }
                 }
                 $ptr->{value} = $val;
             }
         }
     }
     $self->{data} = $data;
     return $data;
 }
 
 sub value {
   my($self, $path) = @_;
 
   $path = unlog4j($path);
 
   my @p = split /::/, $path;
 
   my $found = 0;
   my $r = $self->{data};
 
   while (my $n = shift @p) {
       if (exists $r->{$n}) {
           $r = $r->{$n};
           $found = 1;
       } else {
           $found = 0;
       }
   }
 
   if($found and exists $r->{value}) {
       return $r->{value};
   } else {
       return undef;
   }
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Config/Watch.pm ###
 package Log::Log4perl::Config::Watch;
 
 use constant _INTERNAL_DEBUG => 0;
 
 our $NEXT_CHECK_TIME;
 our $SIGNAL_CAUGHT;
 
 our $L4P_TEST_CHANGE_DETECTED;
 our $L4P_TEST_CHANGE_CHECKED;
 
 sub new {
     my($class, %options) = @_;
 
     my $self = { file            => "",
                  check_interval  => 30,
                  l4p_internal    => 0,
                  signal          => undef,
                  %options,
                  _last_checked_at => 0,
                  _last_timestamp  => 0,
                };
 
     bless $self, $class;
 
     if($self->{signal}) {
         print "Setting up signal handler for '$self->{signal}'\n" if
             _INTERNAL_DEBUG;
 
         my $old_sig_handler = $SIG{$self->{signal}};
         $SIG{$self->{signal}} = sub { 
             print "Caught $self->{signal} signal\n" if _INTERNAL_DEBUG;
             $self->force_next_check();
             $old_sig_handler->(@_) if $old_sig_handler and ref $old_sig_handler eq 'CODE';
         };
         $self->{signal_caught} = 0;
         $SIGNAL_CAUGHT = 0 if $self->{l4p_internal};
     } else {
         $self->change_detected(undef, 1);
         $self->file_has_moved(undef, 1);
     }
 
     return $self;
 }
 
 sub force_next_check {
     my($self) = @_;
 
     $self->{signal_caught}   = 1;
     $self->{next_check_time} = 0;
 
     if( $self->{l4p_internal} ) {
         $SIGNAL_CAUGHT = 1;
         $NEXT_CHECK_TIME = 0;
     }
 }
 
 sub force_next_check_reset {
     my($self) = @_;
 
     $self->{signal_caught} = 0;
     $SIGNAL_CAUGHT = 0 if $self->{l4p_internal};
 }
 
 sub file {
     my($self) = @_;
 
     return $self->{file};
 }
 
 sub signal {
     my($self) = @_;
 
     return $self->{signal};
 }
 
 sub check_interval {
     my($self) = @_;
 
     return $self->{check_interval};
 }
 
 sub file_has_moved {
     my($self, $time, $force) = @_;
 
     my $task = sub {
         my @stat = stat($self->{file});
 
         my $has_moved = 0;
 
         if(! $stat[0]) {
             print "File is gone\n" if _INTERNAL_DEBUG;
             return 1;
         }
 
         my $current_inode = "$stat[0]:$stat[1]";
         print "Current inode: $current_inode\n" if _INTERNAL_DEBUG;
 
         if(exists $self->{_file_inode} and 
             $self->{_file_inode} ne $current_inode) {
             print "Inode changed from $self->{_file_inode} to ",
                   "$current_inode\n" if _INTERNAL_DEBUG;
             $has_moved = 1;
         }
 
         $self->{_file_inode} = $current_inode;
         return $has_moved;
     };
 
     return $self->check($time, $task, $force);
 }
 
 sub change_detected {
     my($self, $time, $force) = @_;
 
     my $task = sub {
         my @stat = stat($self->{file});
         my $new_timestamp = $stat[9];
 
         $L4P_TEST_CHANGE_CHECKED = 1;
 
         if(! defined $new_timestamp) {
             if($self->{l4p_internal}) {
                 return undef;
             }
             $L4P_TEST_CHANGE_DETECTED = 1;
             return 1;
         }
 
         if($new_timestamp > $self->{_last_timestamp}) {
             $self->{_last_timestamp} = $new_timestamp;
             print "Change detected (file=$self->{file} store=$new_timestamp)\n"
                   if _INTERNAL_DEBUG;
             $L4P_TEST_CHANGE_DETECTED = 1;
             return 1; 
         }
            
         print "$self->{file} unchanged (file=$new_timestamp ",
               "stored=$self->{_last_timestamp})!\n" if _INTERNAL_DEBUG;
         return "";  
     };
 
     return $self->check($time, $task, $force);
 }
 
 sub check {
     my($self, $time, $task, $force) = @_;
 
     $time = time() unless defined $time;
 
     if( $self->{signal_caught} or $SIGNAL_CAUGHT ) {
        $force = 1;
        $self->force_next_check_reset();
        print "Caught signal, forcing check\n" if _INTERNAL_DEBUG;
 
     }
 
     print "Soft check (file=$self->{file} time=$time)\n" if _INTERNAL_DEBUG;
 
     if(!$force and
        $self->{_last_checked_at} + 
        $self->{check_interval} > $time) {
         print "No need to check\n" if _INTERNAL_DEBUG;
         return ""; 
     }
        
     $self->{_last_checked_at} = $time;
 
     $self->{next_check_time} = $time + $self->{check_interval};
     $NEXT_CHECK_TIME = $self->{next_check_time} if $self->{l4p_internal};
 
     print "Hard check (file=$self->{file} time=$time)\n" if _INTERNAL_DEBUG;
     return $task->($time);
 }
 
 1;
 
 __END__
 
### Log/Log4perl/DateFormat.pm ###
 package Log::Log4perl::DateFormat;
 use warnings;
 use strict;
 
 use Carp qw( croak );
 
 our $GMTIME = 0;
 
 my @MONTH_NAMES = qw(
 January February March April May June July
 August September October November December);
 
 my @WEEK_DAYS = qw(
 Sunday Monday Tuesday Wednesday Thursday Friday Saturday);
 
 sub new {
     my($class, $format) = @_;
 
     my $self = { 
                   stack => [],
                   fmt   => undef,
                };
 
     bless $self, $class;
 
     if($format eq "ABSOLUTE") {
         $format = "HH:mm:ss,SSS";
     } elsif($format eq "DATE") {
         $format = "dd MMM yyyy HH:mm:ss,SSS";
     } elsif($format eq "ISO8601") {
         $format = "yyyy-MM-dd HH:mm:ss,SSS";
     } elsif($format eq "APACHE") {
         $format = "[EEE MMM dd HH:mm:ss yyyy]";
     }
 
     if($format) { 
         $self->prepare($format);
     }
 
     return $self;
 }
 
 sub prepare {
     my($self, $format) = @_;
 
 
     my $fmt = "";
 
     foreach my $chunk ( split /('(?:''|[^'])*')/, $format ) {
         if ( $chunk =~ /\A'(.*)'\z/ ) {
             my $literal = $1;
             $literal =~ s/''/'/g;
             $literal =~ s/\%/\%\%/g;
             $fmt .= $literal;
         } elsif ( $chunk =~ /'/ ) {
             croak "bad date format \"$format\": " .
                   "unmatched single quote in chunk \"$chunk\"";
         } else {
             $chunk =~ s/(([GyMdhHmsSEeDFwWakKzZ])\2*)/$self->rep($1)/ge;
             $fmt .= $chunk;
         }
     }
 
     return $self->{fmt} = $fmt;
 }
 
 sub rep {
     my ($self, $string) = @_;
 
     my $first = substr $string, 0, 1;
     my $len   = length $string;
 
     my $time=time();
     my @g = gmtime($time);
     my @t = localtime($time);
     my $z = $t[1]-$g[1]+($t[2]-$g[2])*60+($t[7]-$g[7])*1440+
             ($t[5]-$g[5])*(525600+(abs($t[7]-$g[7])>364)*1440);
     my $offset = sprintf("%+.2d%.2d", $z/60, "00");
 
 
     
     
 
 
     if($first eq "G") {
         return "AD";
 
     } elsif($first eq "e") {
         push @{$self->{stack}}, [0, sub { return $_[1] }];
         return "%d";
 
     } elsif($first eq "y") {
         if($len >= 4) {
             push @{$self->{stack}}, [5, sub { return $_[0] + 1900 }];
             return "%04d";
         } else {
             push @{$self->{stack}}, [5, sub { $_[0] % 100 }];
             return "%02d";
         }
 
     } elsif($first eq "M") {
         if($len >= 3) {
             push @{$self->{stack}}, [4, sub { return $MONTH_NAMES[$_[0]] }];
            if($len >= 4) {
                 return "%s";
             } else {
                return "%.3s";
             }
         } elsif($len == 2) {
             push @{$self->{stack}}, [4, sub { $_[0]+1 }];
             return "%02d";
         } else {
             push @{$self->{stack}}, [4, sub { $_[0]+1 }];
             return "%d";
         }
 
     } elsif($first eq "d") {
         push @{$self->{stack}}, [3, sub { return $_[0] }];
         return "%0" . $len . "d";
 
     } elsif($first eq "h") {
         push @{$self->{stack}}, [2, sub { ($_[0] % 12) || 12 }];
         return "%0" . $len . "d";
 
     } elsif($first eq "H") {
         push @{$self->{stack}}, [2, sub { return $_[0] }];
         return "%0" . $len . "d";
 
     } elsif($first eq "m") {
         push @{$self->{stack}}, [1, sub { return $_[0] }];
         return "%0" . $len . "d";
 
     } elsif($first eq "s") {
         push @{$self->{stack}}, [0, sub { return $_[0] }];
         return "%0" . $len . "d";
 
     } elsif($first eq "E") {
         push @{$self->{stack}}, [6, sub { $WEEK_DAYS[$_[0]] }];
        if($len >= 4) {
             return "%${len}s";
         } else {
            return "%.3s";
         }
 
     } elsif($first eq "D") {
         push @{$self->{stack}}, [7, sub { $_[0] + 1}];
         return "%0" . $len . "d";
 
     } elsif($first eq "a") {
         push @{$self->{stack}}, [2, sub { $_[0] < 12 ? "AM" : "PM" }];
         return "%${len}s";
 
     } elsif($first eq "S") {
         push @{$self->{stack}}, 
              [9, sub { substr sprintf("%06d", $_[0]), 0, $len }];
         return "%s";
 
     } elsif($first eq "Z") {
         push @{$self->{stack}}, [10, sub { $offset }];
         return "$offset";
 
     } else {
         return "-- '$first' not (yet) implemented --";
     }
 
     return $string;
 }
 
 sub format {
     my($self, $secs, $msecs) = @_;
 
     $msecs = 0 unless defined $msecs;
 
     my @time; 
 
     if($GMTIME) {
         @time = gmtime($secs);
     } else {
         @time = localtime($secs);
     }
 
     push @time, $msecs;
 
     my @values = ();
 
     for(@{$self->{stack}}) {
         my($val, $code) = @$_;
         if($code) {
             push @values, $code->($time[$val], $secs);
         } else {
             push @values, $time[$val];
         }
     }
 
     return sprintf($self->{fmt}, @values);
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Filter.pm ###
 package Log::Log4perl::Filter;
 
 use 5.006;
 use strict;
 use warnings;
 
 use Log::Log4perl::Level;
 use Log::Log4perl::Config;
 
 use constant _INTERNAL_DEBUG => 0;
 
 our %FILTERS_DEFINED = ();
 
 sub new {
     my($class, $name, $action) = @_;
   
     print "Creating filter $name\n" if _INTERNAL_DEBUG;
 
     my $self = { name => $name };
     bless $self, $class;
 
     if(ref($action) eq "CODE") {
         $self->{ok} = $action;
     } else {
         die "Code for ($name/$action) not properly defined";
     }
 
     return $self;
 }
 
 sub register {         
     my($self) = @_;
 
     by_name($self->{name}, $self);
 }
 
 sub by_name {        
     my($name, $value) = @_;
 
     if(defined $value) {
         $FILTERS_DEFINED{$name} = $value;
     }
 
     if(exists $FILTERS_DEFINED{$name}) {
         return $FILTERS_DEFINED{$name};
     } else {
         return undef;
     }
 }
 
 sub reset {
     %FILTERS_DEFINED = ();
 }
 
 sub ok {
     my($self, %p) = @_;
 
     print "Calling $self->{name}'s ok method\n" if _INTERNAL_DEBUG;
 
     die "This is to be overridden by the filter" unless
          defined $self->{ok};
 
     local($_) = join $
                      Log::Log4perl::JOIN_MSG_ARRAY_CHAR, @{$p{message}};
     print "\$_ is '$_'\n" if _INTERNAL_DEBUG;
 
     my $decision = $self->{ok}->(%p);
 
     print "$self->{name}'s ok'ed: ", 
           ($decision ? "yes" : "no"), "\n" if _INTERNAL_DEBUG;
 
     return $decision;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Filter/Boolean.pm ###
 package Log::Log4perl::Filter::Boolean;
 
 use 5.006;
 
 use strict;
 use warnings;
 
 use Log::Log4perl::Level;
 use Log::Log4perl::Config;
 
 use constant _INTERNAL_DEBUG => 0;
 
 use base qw(Log::Log4perl::Filter);
 
 sub new {
     my ($class, %options) = @_;
 
     my $self = { params => {},
                  %options,
                };
      
     bless $self, $class;
      
     print "Compiling '$options{logic}'\n" if _INTERNAL_DEBUG;
 
     $self->compile_logic($options{logic});
 
     return $self;
 }
 
 sub ok {
      my ($self, %p) = @_;
 
      return $self->eval_logic(\%p);
 }
 
 sub compile_logic {
     my ($self, $logic) = @_;
 
     while($logic =~ /([\w_-]+)/g) {
         my $filter = Log::Log4perl::Filter::by_name($1);
         die "Filter $filter required by Boolean filter, but not defined" 
             unless $filter;
 
         $self->{params}->{$1} = $filter;
     }
 
     my $plist = join ', ', map { '$' . $_ } keys %{$self->{params}};
 
         $logic =~ s/([\w_-]+)/\&\$$1/g;
 
     my $func = <<EOT;
         sub { 
             my($plist) = \@_;
             $logic;
         }
 EOT
 
     print "func=$func\n" if _INTERNAL_DEBUG;
 
     my $eval_func = eval $func;
 
     if(! $eval_func) {
         die "Syntax error in Boolean filter logic: $eval_func";
     }
 
     $self->{eval_func} = $eval_func;
 }
 
 sub eval_logic {
     my($self, $p) = @_;
 
     my @plist = ();
 
     for my $param (keys %{$self->{params}}) {
         print "Passing filter $param\n" if _INTERNAL_DEBUG;
         push(@plist, sub {
             return $self->{params}->{$param}->ok(%$p) ? 1 : 0
         });
     }
 
     print "Passing in (", join(', ', @plist), ")\n" if _INTERNAL_DEBUG;
     return $self->{eval_func}->(@plist);
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Filter/LevelMatch.pm ###
 package Log::Log4perl::Filter::LevelMatch;
 
 use 5.006;
 
 use strict;
 use warnings;
 
 use Log::Log4perl::Level;
 use Log::Log4perl::Config;
 use Log::Log4perl::Util qw( params_check );
 
 use constant _INTERNAL_DEBUG => 0;
 
 use base qw(Log::Log4perl::Filter);
 
 sub new {
     my ($class, %options) = @_;
 
     my $self = { LevelToMatch  => '',
                  AcceptOnMatch => 1,
                  %options,
                };
      
     params_check( $self,
                   [ qw( LevelToMatch ) ], 
                   [ qw( name AcceptOnMatch ) ] 
                 );
 
     $self->{AcceptOnMatch} = Log::Log4perl::Config::boolean_to_perlish(
                                                 $self->{AcceptOnMatch});
 
     bless $self, $class;
 
     return $self;
 }
 
 sub ok {
      my ($self, %p) = @_;
 
      if($self->{LevelToMatch} eq $p{log4p_level}) {
          print "Levels match\n" if _INTERNAL_DEBUG;
          return $self->{AcceptOnMatch};
      } else {
          print "Levels don't match\n" if _INTERNAL_DEBUG;
          return !$self->{AcceptOnMatch};
      }
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Filter/LevelRange.pm ###
 package Log::Log4perl::Filter::LevelRange;
 
 use 5.006;
 
 use strict;
 use warnings;
 
 use Log::Log4perl::Level;
 use Log::Log4perl::Config;
 use Log::Log4perl::Util qw( params_check );
 
 use constant _INTERNAL_DEBUG => 0;
 
 use base "Log::Log4perl::Filter";
 
 sub new {
     my ($class, %options) = @_;
 
     my $self = { LevelMin      => 'DEBUG',
                  LevelMax      => 'FATAL',
                  AcceptOnMatch => 1,
                  %options,
                };
      
     params_check( $self,
                   [ qw( LevelMin LevelMax ) ], 
                   [ qw( name AcceptOnMatch ) ] 
                 );
 
     $self->{AcceptOnMatch} = Log::Log4perl::Config::boolean_to_perlish(
                                                 $self->{AcceptOnMatch});
 
     bless $self, $class;
 
     return $self;
 }
 
 sub ok {
      my ($self, %p) = @_;
 
      if(Log::Log4perl::Level::to_priority($self->{LevelMin}) <= 
         Log::Log4perl::Level::to_priority($p{log4p_level}) and
         Log::Log4perl::Level::to_priority($self->{LevelMax}) >= 
         Log::Log4perl::Level::to_priority($p{log4p_level})) {
          return $self->{AcceptOnMatch};
      } else {
          return ! $self->{AcceptOnMatch};
      }
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Filter/MDC.pm ###
 package Log::Log4perl::Filter::MDC;
 use strict;
 use warnings;
 
 use Log::Log4perl::Util qw( params_check );
 
 use base "Log::Log4perl::Filter";
 
 sub new {
     my ( $class, %options ) = @_;
 
     my $self = {%options};
 
     params_check( $self, [qw( KeyToMatch RegexToMatch )] );
 
     $self->{RegexToMatch} = qr/$self->{RegexToMatch}/;
 
     bless $self, $class;
 
     return $self;
 }
 
 sub ok {
     my ( $self, %p ) = @_;
 
     my $context = Log::Log4perl::MDC->get_context;
 
     my $value = $context->{ $self->{KeyToMatch} };
     return 1
         if defined $value && $value =~ $self->{RegexToMatch};
 
     return 0;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Filter/StringMatch.pm ###
 package Log::Log4perl::Filter::StringMatch;
 
 use 5.006;
 
 use strict;
 use warnings;
 
 use Log::Log4perl::Config;
 use Log::Log4perl::Util qw( params_check );
 
 use constant _INTERNAL_DEBUG => 0;
 
 use base "Log::Log4perl::Filter";
 
 sub new {
      my ($class, %options) = @_;
 
      print join('-', %options) if _INTERNAL_DEBUG;
 
      my $self = { StringToMatch => undef,
                   AcceptOnMatch => 1,
                   %options,
                 };
      
      params_check( $self,
                   [ qw( StringToMatch ) ], 
                   [ qw( name AcceptOnMatch ) ] 
                 );
 
      $self->{AcceptOnMatch} = Log::Log4perl::Config::boolean_to_perlish(
                                                  $self->{AcceptOnMatch});
 
      $self->{StringToMatch} = qr($self->{StringToMatch});
 
      bless $self, $class;
 
      return $self;
 }
 
 sub ok {
      my ($self, %p) = @_;
 
      local($_) = join $
                      Log::Log4perl::JOIN_MSG_ARRAY_CHAR, @{$p{message}};
 
      if($_ =~ $self->{StringToMatch}) {
          print "Strings match\n" if _INTERNAL_DEBUG;
          return $self->{AcceptOnMatch};
      } else {
          print "Strings don't match ($_/$self->{StringToMatch})\n" 
              if _INTERNAL_DEBUG;
          return !$self->{AcceptOnMatch};
      }
 }
 
 1;
 
 __END__
 
### Log/Log4perl/InternalDebug.pm ###
 package Log::Log4perl::InternalDebug;
 use warnings;
 use strict;
 
 use File::Temp qw(tempfile);
 use File::Spec;
 
 require Log::Log4perl::Resurrector;
 
 sub enable {
     unshift @INC, \&internal_debug_loader;
 }
 
 sub internal_debug_fh {
     my($file) = @_;
 
     local($/) = undef;
     open FILE, "<$file" or die "Cannot open $file";
     my $text = <FILE>;
     close FILE;
 
     my($tmp_fh, $tmpfile) = tempfile( UNLINK => 1 );
 
     $text =~ s/_INTERNAL_DEBUG(?!\s*=>)/1/g;
 
     print $tmp_fh $text;
     seek $tmp_fh, 0, 0;
 
     return $tmp_fh;
 }
 
 sub internal_debug_loader {
     my ($code, $module) = @_;
 
     if($module !~ m#^Log/Log4perl#) {
         return undef;
     }
 
     my $path = $module;
     if(!-f $path) {
         $path = Log::Log4perl::Resurrector::pm_search( $module );
     }
 
     my $fh = internal_debug_fh($path);
 
     my $abs_path = File::Spec->rel2abs( $path );
     $INC{$module} = $abs_path;
 
     return $fh;
 }
 
 sub resurrector_init {
     unshift @INC, \&resurrector_loader;
 }
 
 sub import {
   enable();
 }
 
 1;
 
 __END__
 
### Log/Log4perl/JavaMap.pm ###
 package Log::Log4perl::JavaMap;
 
 use Carp;
 use strict;
 
 use constant _INTERNAL_DEBUG => 0;
 
 our %translate = (
     'org.apache.log4j.ConsoleAppender' => 
         'Log::Log4perl::JavaMap::ConsoleAppender',
     'org.apache.log4j.FileAppender'    => 
         'Log::Log4perl::JavaMap::FileAppender',
     'org.apache.log4j.RollingFileAppender'    => 
         'Log::Log4perl::JavaMap::RollingFileAppender',
     'org.apache.log4j.TestBuffer'    => 
         'Log::Log4perl::JavaMap::TestBuffer',
      'org.apache.log4j.jdbc.JDBCAppender'    => 
         'Log::Log4perl::JavaMap::JDBCAppender',
      'org.apache.log4j.SyslogAppender'    => 
         'Log::Log4perl::JavaMap::SyslogAppender',
      'org.apache.log4j.NTEventLogAppender'    => 
         'Log::Log4perl::JavaMap::NTEventLogAppender',
 );
 
 our %user_defined;
 
 sub get {
     my ($appender_name, $appender_data) = @_;
 
     print "Trying to map $appender_name\n" if _INTERNAL_DEBUG;
 
     $appender_data->{value} ||
             die "ERROR: you didn't tell me how to implement your appender " .
                 "'$appender_name'";
 
     my $perl_class = $translate{$appender_data->{value}} || 
                      $user_defined{$appender_data->{value}} ||
             die "ERROR:  I don't know how to make a '$appender_data->{value}' " .
                 "to implement your appender '$appender_name', that's not a " .
                 "supported class\n";
     eval {
         eval "require $perl_class";  
         die $@ if $@;
     };
     $@ and die "ERROR: trying to set appender for $appender_name to " .
                "$appender_data->{value} using $perl_class failed\n$@  \n";
 
     my $app = $perl_class->new($appender_name, $appender_data);
     return $app;
 }
 
 sub translate {
     my $java_class = shift;
 
     return $translate{$java_class} || 
             $user_defined{$java_class};
 }
 
 1;
 
 
### Log/Log4perl/JavaMap/ConsoleAppender.pm ###
 package Log::Log4perl::JavaMap::ConsoleAppender;
 
 use Carp;
 use strict;
 use Log::Dispatch::Screen;
 
 
 sub new {
     my ($class, $appender_name, $data) = @_;
     my $stderr;
 
     if (my $t = $data->{Target}{value}) {
         if ($t eq 'System.out') {
             $stderr = 0;
         }elsif ($t eq 'System.err') {
             $stderr = 1;
         }else{
             die "ERROR: illegal value '$t' for $data->{value}.Target' in appender $appender_name\n";
         }
     }elsif (defined $data->{stderr}{value}){
         $stderr = $data->{stderr}{value};
     }else{
         $stderr = 0;
     }
 
     return Log::Log4perl::Appender->new("Log::Dispatch::Screen",
         name   => $appender_name,
         stderr => $stderr );
 }
 
 
 1;
 
 
 
### Log/Log4perl/JavaMap/FileAppender.pm ###
 package Log::Log4perl::JavaMap::FileAppender;
 
 use Carp;
 use strict;
 use Log::Dispatch::File;
 
 
 sub new {
     my ($class, $appender_name, $data) = @_;
     my $stderr;
 
     my $filename =  $data->{File}{value} || 
                 $data->{filename}{value} || 
                 die "'File' not supplied for appender '$appender_name', required for a '$data->{value}'\n";
 
     my $mode;
     if (defined($data->{Append}{value})){
         if (lc $data->{Append}{value} eq 'true' || $data->{Append}{value} == 1){
             $mode = 'append';
         }elsif (lc $data->{Append}{value} eq 'false' || $data->{Append}{value} == 0) {
             $mode = 'write';
         }elsif($data->{Append} =~ /^(write|append)$/){
             $mode = $data->{Append}
         }else{
             die "'$data->{Append}' is not a legal value for Append for appender '$appender_name', '$data->{value}'\n";
         }
     }else{
         $mode = 'append';
     }
 
     my $autoflush;
     if (defined($data->{BufferedIO}{value})){
         if (lc $data->{BufferedIO}{value} eq 'true' || $data->{BufferedIO}{value}){
             $autoflush = 1;
         }elsif (lc $data->{BufferedIO}{value} eq 'true' || ! $data->{BufferedIO}{value}) {
             $autoflush = 0;
         }else{
             die "'$data->{BufferedIO}' is not a legal value for BufferedIO for appender '$appender_name', '$data->{value}'\n";
         }
     }else{
         $autoflush = 1;
     }
 
 
     return Log::Log4perl::Appender->new("Log::Dispatch::File",
         name      => $appender_name,
         filename  => $filename,
         mode      => $mode,
         autoflush => $autoflush,
     );
 }
 
 1;
 
### Log/Log4perl/JavaMap/JDBCAppender.pm ###
 package Log::Log4perl::JavaMap::JDBCAppender;
 
 use Carp;
 use strict;
 
 sub new {
     my ($class, $appender_name, $data) = @_;
     my $stderr;
 
     my $pwd =  $data->{password}{value} || 
                 die "'password' not supplied for appender '$appender_name', required for a '$data->{value}'\n";
 
     my $username =  $data->{user}{value} || 
                 $data->{username}{value} || 
                 die "'user' not supplied for appender '$appender_name', required for a '$data->{value}'\n";
 
 
     my $sql =  $data->{sql}{value} || 
                 die "'sql' not supplied for appender '$appender_name', required for a '$data->{value}'\n";
 
 
     my $dsn;
 
     my $databaseURL = $data->{URL}{value};
     if ($databaseURL) {
         $databaseURL =~ m|^jdbc:(.+?):(.+?)://(.+?):(.+?);(.+)|;
         my $driverName = $1;
         my $databaseName = $2;
         my $hostname = $3;
         my $port = $4;
         my $params = $5;
         $dsn = "dbi:$driverName:database=$databaseName;host=$hostname;port=$port;$params";
     }elsif ($data->{datasource}{value}){
         $dsn = $data->{datasource}{value};
     }else{
         die "'databaseURL' not supplied for appender '$appender_name', required for a '$data->{value}'\n";
     }
 
 
     my %bind_value_params;
     foreach my $p (keys %{$data->{params}}){
         $bind_value_params{$p} =  $data->{params}{$p}{value};
     }
 
     return Log::Log4perl::Appender->new("Log::Log4perl::Appender::DBI",
         datasource    => $dsn,
         username      => $username,
         password      => $pwd, 
         sql           => $sql,
         params        => \%bind_value_params,
         warp_message=> $data->{warp_message}{value},  
     );
 }
 
 1;
 
### Log/Log4perl/JavaMap/NTEventLogAppender.pm ###
 package Log::Log4perl::JavaMap::NTEventLogAppender;
 
 use Carp;
 use strict;
 
 
 
 sub new {
     my ($class, $appender_name, $data) = @_;
     my $stderr;
 
     my ($source,   
         );
 
     if (defined $data->{Source}{value}) {
         $source = $data->{Source}{value}
     }elsif (defined $data->{source}{value}){
         $source = $data->{source}{value};
     }else{
         $source = 'user';
     }
 
     
     return Log::Log4perl::Appender->new("Log::Dispatch::Win32EventLog",
         name      => $appender_name,
         source    => $source,
         min_level => 'debug',
     );
 }
 
 1;
 
### Log/Log4perl/JavaMap/RollingFileAppender.pm ###
 package Log::Log4perl::JavaMap::RollingFileAppender;
 
 use Carp;
 use strict;
 use Log::Dispatch::FileRotate 1.10;
 
 
 sub new {
     my ($class, $appender_name, $data) = @_;
     my $stderr;
 
     my $filename =  $data->{File}{value} || 
                 $data->{filename}{value} || 
                 die "'File' not supplied for appender '$appender_name', required for a '$data->{value}'\n";
 
     my $mode;
     if (defined($data->{Append}{value})){
         if (lc $data->{Append}{value} eq 'true' || $data->{Append}{value} == 1){
             $mode = 'append';
         }elsif (lc $data->{Append}{value} eq 'false' || $data->{Append}{value} == 0) {
             $mode = 'write';
         }elsif($data->{Append} =~ /^(write|append)$/){
             $mode = $data->{Append}
         }else{
             die "'$data->{Append}' is not a legal value for Append for appender '$appender_name', '$data->{value}'\n";
         }
     }else{
         $mode = 'append';
     }
 
     my $autoflush;
     if (defined($data->{BufferedIO}{value})){
         if (lc $data->{BufferedIO}{value} eq 'true' || $data->{BufferedIO}{value}){
             $autoflush = 1;
         }elsif (lc $data->{BufferedIO}{value} eq 'true' || ! $data->{BufferedIO}{value}) {
             $autoflush = 0;
         }else{
             die "'$data->{BufferedIO}' is not a legal value for BufferedIO for appender '$appender_name', '$data->{value}'\n";
         }
     }else{
         $autoflush = 1;
     }
 
     my $max;
     if (defined $data->{MaxBackupIndex}{value}) {
         $max = $data->{MaxBackupIndex}{value};
     }elsif (defined $data->{max}{value}){
         $max = $data->{max}{value};
     }else{
         $max = 1;
 
     }
 
     my $size;
     if (defined $data->{MaxFileSize}{value}) {
         $size = $data->{MaxFileSize}{value}
     }elsif (defined $data->{size}{value}){
         $size = $data->{size}{value};
     }else{
         $size = 10_000_000;
     }
 
 
     return Log::Log4perl::Appender->new("Log::Dispatch::FileRotate",
         name      => $appender_name,
         filename  => $filename,
         mode      => $mode,
         autoflush => $autoflush,
         size      => $size,
         max       => $max,
     );
 }
 
 1;
 
### Log/Log4perl/JavaMap/SyslogAppender.pm ###
 package Log::Log4perl::JavaMap::SyslogAppender;
 
 use Carp;
 use strict;
 use Log::Dispatch::Syslog;
 
 
 sub new {
     my ($class, $appender_name, $data) = @_;
     my $stderr;
 
     my ($ident,    
         $logopt,   
         $facility, 
         $socket,   
         );
 
     if (defined $data->{Facility}{value}) {
         $facility = $data->{Facility}{value}
     }elsif (defined $data->{facility}{value}){
         $facility = $data->{facility}{value};
     }else{
         $facility = 'user';
     }
 
     if (defined $data->{Ident}{value}) {
         $ident = $data->{Ident}{value}
     }elsif (defined $data->{ident}{value}){
         $ident = $data->{ident}{value};
     }else{
         $ident = $0;
     }
     
     return Log::Log4perl::Appender->new("Log::Dispatch::Syslog",
         name      => $appender_name,
         facility  => $facility,
         ident     => $ident,
         min_level => 'debug',
     );
 }
 
 1;
 
### Log/Log4perl/JavaMap/TestBuffer.pm ###
 package Log::Log4perl::JavaMap::TestBuffer;
 
 use Carp;
 use strict;
 use Log::Log4perl::Appender::TestBuffer;
 
 use constant _INTERNAL_DEBUG => 0;
 
 sub new {
     my ($class, $appender_name, $data) = @_;
     my $stderr;
 
     return Log::Log4perl::Appender->new("Log::Log4perl::Appender::TestBuffer",
                                         name => $appender_name);
 }
 
 1;
 
### Log/Log4perl/Layout.pm ###
 package Log::Log4perl::Layout;
 
 
 use Log::Log4perl::Layout::SimpleLayout;
 use Log::Log4perl::Layout::PatternLayout;
 use Log::Log4perl::Layout::PatternLayout::Multiline;
 
 
 sub appender_name {
     my ($self, $arg) = @_;
 
     if ($arg) {
         die "setting appender_name unimplemented until it makes sense";
     }
     return $self->{appender_name};
 }
 
 
 sub define {
     ;  
 }
 
 
 sub render {
     die "subclass must implement render";
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Layout/NoopLayout.pm ###
 package Log::Log4perl::Layout::NoopLayout;
 
 
 sub new {
     my $class = shift;
     $class = ref ($class) || $class;
 
     my $self = {
         format      => undef,
         info_needed => {},
         stack       => [],
     };
 
     bless $self, $class;
 
     return $self;
 }
 
 sub render {
     return $_[1];;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Layout/PatternLayout.pm ###
 package Log::Log4perl::Layout::PatternLayout;
 
 use 5.006;
 use strict;
 use warnings;
 
 use constant _INTERNAL_DEBUG => 0;
 
 use Carp;
 use Log::Log4perl::Util;
 use Log::Log4perl::Level;
 use Log::Log4perl::DateFormat;
 use Log::Log4perl::NDC;
 use Log::Log4perl::MDC;
 use Log::Log4perl::Util::TimeTracker;
 use File::Spec;
 use File::Basename;
 
 our $TIME_HIRES_AVAILABLE_WARNED = 0;
 our $HOSTNAME;
 our %GLOBAL_USER_DEFINED_CSPECS = ();
 
 our $CSPECS = 'cCdFHIlLmMnpPrRtTxX%';
 
 BEGIN {
     $HOSTNAME = "unknown.host";
     if(Log::Log4perl::Util::module_available("Sys::Hostname")) {
         require Sys::Hostname;
         $HOSTNAME = Sys::Hostname::hostname();
     }
 }
 
 use base qw(Log::Log4perl::Layout);
 
 no strict qw(refs);
 
 sub new {
     my $class = shift;
     $class = ref ($class) || $class;
 
     my $options       = ref $_[0] eq "HASH" ? shift : {};
     my $layout_string = @_ ? shift : '%m%n';
     
     my $self = {
         format                => undef,
         info_needed           => {},
         stack                 => [],
         CSPECS                => $CSPECS,
         dontCollapseArrayRefs => $options->{dontCollapseArrayRefs}{value},
         last_time             => undef,
         undef_column_value    => 
             (exists $options->{ undef_column_value } 
                 ? $options->{ undef_column_value } 
                 : "[undef]"),
     };
 
     $self->{timer} = Log::Log4perl::Util::TimeTracker->new(
         time_function => $options->{time_function}
     );
 
     if(exists $options->{ConversionPattern}->{value}) {
         $layout_string = $options->{ConversionPattern}->{value};
     }
 
     if(exists $options->{message_chomp_before_newline}) {
         $self->{message_chomp_before_newline} = 
           $options->{message_chomp_before_newline}->{value};
     } else {
         $self->{message_chomp_before_newline} = 1;
     }
 
     bless $self, $class;
 
     foreach my $f (keys %GLOBAL_USER_DEFINED_CSPECS){
         $self->{CSPECS} .= $f;
         $self->{USER_DEFINED_CSPECS}{$f} = $GLOBAL_USER_DEFINED_CSPECS{$f};
     }
 
     foreach my $f (keys %{$options->{cspec}}){
         $self->add_layout_cspec($f, $options->{cspec}{$f}{value});
     }
 
     $layout_string =~ s/\\n/\n/g;
     $layout_string =~ s/\\r/\r/g;
 
     $self->define($layout_string);
 
     return $self;
 }
 
 sub define {
     my($self, $format) = @_;
 
     if($self->{message_chomp_before_newline} and $format =~ /%m%n/) {
         $self->{message_chompable} = 1;
     } else {
         $self->{message_chompable} = 0;
     }
 
     $format =~ s/%(-?\d*(?:\.\d+)?) 
                        ([$self->{CSPECS}])
                        (?:{(.*?)})*/
                        rep($self, $1, $2, $3);
                       /gex;
 
     $self->{printformat} = $format;
 }
 
 sub rep {
     my($self, $num, $op, $curlies) = @_;
 
     return "%%" if $op eq "%";
 
     if($op eq "d") {
         if(defined $curlies) {
             $curlies = Log::Log4perl::DateFormat->new($curlies);
         } else {
             $curlies = Log::Log4perl::DateFormat->new("yyyy/MM/dd HH:mm:ss");
         }
     } elsif($op eq "m") {
         $curlies = $self->curlies_csv_parse($curlies);
     }
 
     push @{$self->{stack}}, [$op, $curlies];
 
     $self->{info_needed}->{$op}++;
 
     return "%${num}s";
 }
 
 sub curlies_csv_parse {
     my($self, $curlies) = @_;
 
     my $data = {};
 
     if(defined $curlies and length $curlies) {
         $curlies =~ s/\s//g;
 
         for my $field (split /,/, $curlies) {
             my($key, $value) = split /=/, $field;
             $data->{$key} = $value;
         }
     }
 
     return $data;
 }
 
 sub render {
     my($self, $message, $category, $priority, $caller_level) = @_;
 
     $caller_level = 0 unless defined  $caller_level;
 
     my %info    = ();
 
     $info{m}    = $message;
     chomp $info{m} if $self->{message_chompable};
 
     my @results = ();
 
     my $caller_offset = Log::Log4perl::caller_depth_offset( $caller_level );
 
     if($self->{info_needed}->{L} or
        $self->{info_needed}->{F} or
        $self->{info_needed}->{C} or
        $self->{info_needed}->{l} or
        $self->{info_needed}->{M} or
        $self->{info_needed}->{T} or
        0
       ) {
 
         my ($package, $filename, $line, 
             $subroutine, $hasargs,
             $wantarray, $evaltext, $is_require, 
             $hints, $bitmask) = caller($caller_offset);
 
         unless(defined $bitmask) {
             for($package, 
                 $filename, $line,
                 $subroutine, $hasargs,
                 $wantarray, $evaltext, $is_require,
                 $hints, $bitmask) {
                 $_ = '[undef]' unless defined $_;
             }
         }
 
         $info{L} = $line;
         $info{F} = $filename;
         $info{C} = $package;
 
         if($self->{info_needed}->{M} or
            $self->{info_needed}->{l} or
            0) {
             my $levels_up = 1; 
             {
                 my @callinfo = caller($caller_offset+$levels_up);
 
                 if(_INTERNAL_DEBUG) {
                     callinfo_dump( $caller_offset, \@callinfo );
                 }
 
                 $subroutine = $callinfo[3];
                 if(defined $subroutine and
                    $subroutine eq "(eval)") {
                     print "Inside an eval, one up\n" if _INTERNAL_DEBUG;
                     $levels_up++;
                     redo;
                 }
             }
             $subroutine = "main::" unless $subroutine;
             print "Subroutine is '$subroutine'\n" if _INTERNAL_DEBUG;
             $info{M} = $subroutine;
             $info{l} = "$subroutine $filename ($line)";
         }
     }
 
     $info{X} = "[No curlies defined]";
     $info{x} = Log::Log4perl::NDC->get() if $self->{info_needed}->{x};
     $info{c} = $category;
     $info{d} = 1; 
     $info{n} = "\n";
     $info{p} = $priority;
     $info{P} = $$;
     $info{H} = $HOSTNAME;
 
     my $current_time;
 
     if($self->{info_needed}->{r} or $self->{info_needed}->{R}) {
         if(!$TIME_HIRES_AVAILABLE_WARNED++ and 
            !$self->{timer}->hires_available()) {
             warn "Requested %r/%R pattern without installed Time::HiRes\n";
         }
         $current_time = [$self->{timer}->gettimeofday()];
     }
 
     if($self->{info_needed}->{r}) {
         $info{r} = $self->{timer}->milliseconds( $current_time );
     }
     if($self->{info_needed}->{R}) {
         $info{R} = $self->{timer}->delta_milliseconds( $current_time );
     }
 
     if($self->{info_needed}->{T}) {
         local $Carp::CarpLevel =
               $Carp::CarpLevel + $caller_offset;
         my $mess = Carp::longmess(); 
         chomp($mess);
         $mess =~ s/(?:\A\s*at.*\n|^\s*)//mg;
         $mess =~ s/\n/, /g;
         $info{T} = $mess;
     }
 
     $info{t} = "N/A";
 
     for my $e (@{$self->{stack}}) {
         my($op, $curlies) = @$e;
 
         my $result;
 
         if(exists $self->{USER_DEFINED_CSPECS}->{$op}) {
             next unless $self->{info_needed}->{$op};
             $self->{curlies} = $curlies;
             $result = $self->{USER_DEFINED_CSPECS}->{$op}->($self, 
                               $message, $category, $priority, 
                               $caller_offset+1);
         } elsif(exists $info{$op}) {
             $result = $info{$op};
             if($curlies) {
                 $result = $self->curly_action($op, $curlies, $info{$op},
                                               $self->{printformat}, \@results);
             } else {
                 if($op eq 'd') {
                     $result = $info{$op}->format($self->{timer}->gettimeofday());
                 }
             }
         } else {
             warn "Format %'$op' not implemented (yet)";
             $result = "FORMAT-ERROR";
         }
 
         $result = $self->{undef_column_value} unless defined $result;
         push @results, $result;
     }
 
     if( scalar @results == 1 and
         !defined $results[0] ) {
         return undef;
     }
 
     return (sprintf $self->{printformat}, @results);
 }
 
 sub curly_action {
     my($self, $ops, $curlies, $data, $printformat, $results) = @_;
 
     if($ops eq "c") {
         $data = shrink_category($data, $curlies);
     } elsif($ops eq "C") {
         $data = shrink_category($data, $curlies);
     } elsif($ops eq "X") {
         $data = Log::Log4perl::MDC->get($curlies);
     } elsif($ops eq "d") {
         $data = $curlies->format( $self->{timer}->gettimeofday() );
     } elsif($ops eq "M") {
         $data = shrink_category($data, $curlies);
     } elsif($ops eq "m") {
         if(exists $curlies->{chomp}) {
             chomp $data;
         }
         if(exists $curlies->{indent}) {
             if(defined $curlies->{indent}) {
                 $data =~ s/\n/ "\n" . (" " x $curlies->{indent})/ge;
             } else {
                 no warnings; 
                 my $indent = length sprintf $printformat, @$results;
                 $data =~ s/\n/ "\n" . (" " x $indent)/ge;
             }
         }
     } elsif($ops eq "F") {
         my @parts = File::Spec->splitdir($data);
         if(@parts > $curlies) {
             splice @parts, 0, @parts - $curlies;
         }
         $data = File::Spec->catfile(@parts);
     } elsif($ops eq "p") {
         $data = substr $data, 0, $curlies;
     }
 
     return $data;
 }
 
 sub shrink_category {
     my($category, $len) = @_;
 
     my @components = split /\.|::/, $category;
 
     if(@components > $len) {
         splice @components, 0, @components - $len;
         $category = join '.', @components;
     } 
 
     return $category;
 }
 
 sub add_global_cspec {
 
     unless($Log::Log4perl::ALLOW_CODE_IN_CONFIG_FILE) {
         die "\$Log::Log4perl::ALLOW_CODE_IN_CONFIG_FILE setting " .
             "prohibits user defined cspecs";
     }
 
     my ($letter, $perlcode) = @_;
 
     croak "Illegal value '$letter' in call to add_global_cspec()"
         unless ($letter =~ /^[a-zA-Z]$/);
 
     croak "Missing argument for perlcode for 'cspec.$letter' ".
           "in call to add_global_cspec()"
         unless $perlcode;
 
     croak "Please don't redefine built-in cspecs [$CSPECS]\n".
           "like you do for \"cspec.$letter\"\n "
         if ($CSPECS =~/$letter/);
 
     if (ref $perlcode eq 'CODE') {
         $GLOBAL_USER_DEFINED_CSPECS{$letter} = $perlcode;
 
     }elsif (! ref $perlcode){
         
         $GLOBAL_USER_DEFINED_CSPECS{$letter} = 
             Log::Log4perl::Config::compile_if_perl($perlcode);
 
         if ($@) {
             die qq{Compilation failed for your perl code for }.
                 qq{"log4j.PatternLayout.cspec.$letter":\n}.
                 qq{This is the error message: \t$@\n}.
                 qq{This is the code that failed: \n$perlcode\n};
         }
 
         croak "eval'ing your perlcode for 'log4j.PatternLayout.cspec.$letter' ".
               "doesn't return a coderef \n".
               "Here is the perl code: \n\t$perlcode\n "
             unless (ref $GLOBAL_USER_DEFINED_CSPECS{$letter} eq 'CODE');
 
     }else{
         croak "I don't know how to handle perlcode=$perlcode ".
               "for 'cspec.$letter' in call to add_global_cspec()";
     }
 }
 
 sub add_layout_cspec {
     my ($self, $letter, $perlcode) = @_;
 
     unless($Log::Log4perl::ALLOW_CODE_IN_CONFIG_FILE) {
         die "\$Log::Log4perl::ALLOW_CODE_IN_CONFIG_FILE setting " .
             "prohibits user defined cspecs";
     }
 
     croak "Illegal value '$letter' in call to add_layout_cspec()"
         unless ($letter =~ /^[a-zA-Z]$/);
 
     croak "Missing argument for perlcode for 'cspec.$letter' ".
           "in call to add_layout_cspec()"
         unless $perlcode;
 
     croak "Please don't redefine built-in cspecs [$CSPECS] \n".
           "like you do for 'cspec.$letter'"
         if ($CSPECS =~/$letter/);
 
     if (ref $perlcode eq 'CODE') {
 
         $self->{USER_DEFINED_CSPECS}{$letter} = $perlcode;
 
     }elsif (! ref $perlcode){
         
         $self->{USER_DEFINED_CSPECS}{$letter} =
             Log::Log4perl::Config::compile_if_perl($perlcode);
 
         if ($@) {
             die qq{Compilation failed for your perl code for }.
                 qq{"cspec.$letter":\n}.
                 qq{This is the error message: \t$@\n}.
                 qq{This is the code that failed: \n$perlcode\n};
         }
         croak "eval'ing your perlcode for 'cspec.$letter' ".
               "doesn't return a coderef \n".
               "Here is the perl code: \n\t$perlcode\n "
             unless (ref $self->{USER_DEFINED_CSPECS}{$letter} eq 'CODE');
 
 
     }else{
         croak "I don't know how to handle perlcode=$perlcode ".
               "for 'cspec.$letter' in call to add_layout_cspec()";
     }
 
     $self->{CSPECS} .= $letter;
 }
 
 sub callinfo_dump {
     my($level, $info) = @_;
 
     my @called_by = caller(0);
 
     $called_by[1] = basename $called_by[1];
     print "caller($level) at $called_by[1]-$called_by[2] returned ";
 
     my @by_idx;
 
 
     my $i = 0;
     for my $field (qw(package filename line subroutine hasargs
                       wantarray evaltext is_require hints bitmask)) {
         $by_idx[$i] = $field;
         $i++;
     }
 
     $i = 0;
     for my $value (@$info) {
         my $field = $by_idx[ $i ];
         print "$field=", 
               (defined $info->[$i] ? $info->[$i] : "[undef]"),
               " ";
         $i++;
     }
 
     print "\n";
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Layout/PatternLayout/Multiline.pm ###
 #!/usr/bin/perl
 
 package Log::Log4perl::Layout::PatternLayout::Multiline;
 use base qw(Log::Log4perl::Layout::PatternLayout);
 
 sub render {
     my($self, $message, $category, $priority, $caller_level) = @_;
 
     my @messages = split /\r?\n/, $message;
 
     $caller_level = 0 unless defined $caller_level;
 
     my $result = '';
 
     for my $msg ( @messages ) {
         $result .= $self->SUPER::render(
             $msg, $category, $priority, $caller_level + 1
         );
     }
     return $result;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Layout/SimpleLayout.pm ###
 package Log::Log4perl::Layout::SimpleLayout;
 
 use 5.006;
 use strict;
 use warnings;
 use Log::Log4perl::Level;
 
 no strict qw(refs);
 use base qw(Log::Log4perl::Layout);
 
 sub new {
     my $class = shift;
     $class = ref ($class) || $class;
 
     my $self = {
         format      => undef,
         info_needed => {},
         stack       => [],
     };
 
     bless $self, $class;
 
     return $self;
 }
 
 sub render {
     my($self, $message, $category, $priority, $caller_level) = @_;
 
     return "$priority - $message\n";
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Level.pm ###
 package Log::Log4perl::Level;
 
 use 5.006;
 use strict;
 use warnings;
 use Carp;
 
 use constant ALL_INT   => 0;
 use constant TRACE_INT =>  5000;
 use constant DEBUG_INT => 10000;
 use constant INFO_INT  => 20000;
 use constant WARN_INT  => 30000;
 use constant ERROR_INT => 40000;
 use constant FATAL_INT => 50000;
 use constant OFF_INT   => (2 ** 31) - 1;
 
 no strict qw(refs);
 use vars qw(%PRIORITY %LEVELS %SYSLOG %L4P_TO_LD);
 
 %PRIORITY = (); 
 %LEVELS = () unless (%LEVELS);
 %SYSLOG = () unless (%SYSLOG);
 %L4P_TO_LD = () unless (%L4P_TO_LD);
 
 sub add_priority {
   my ($prio, $intval, $syslog, $log_dispatch_level) = @_;
   $prio = uc($prio); 
 
   $PRIORITY{$prio}    = $intval;
   $LEVELS{$intval}    = $prio;
 
 
   $log_dispatch_level = 7 unless defined $log_dispatch_level;
   
   $L4P_TO_LD{$prio}  = $log_dispatch_level;
 
   $SYSLOG{$prio}      = $syslog if defined($syslog);
 }
 
 add_priority("OFF",   OFF_INT,   -1, 7);
 add_priority("FATAL", FATAL_INT,  0, 7);
 add_priority("ERROR", ERROR_INT,  3, 4);
 add_priority("WARN",  WARN_INT,   4, 3);
 add_priority("INFO",  INFO_INT,   6, 1);
 add_priority("DEBUG", DEBUG_INT,  7, 0);
 add_priority("TRACE", TRACE_INT,  8, 0);
 add_priority("ALL",   ALL_INT,    8, 0);
 
 sub numerically {$a <=> $b}
 
 sub import {
     my($class, $namespace) = @_;
            
     if(defined $namespace) {
         $namespace .= "::" unless $namespace =~ /::$/;
     } else {
         $namespace = caller(0) . "::";
     }
 
     for my $key (keys %PRIORITY) {
         my $name  = "$namespace$key";
         my $value = $PRIORITY{$key};
         *{"$name"} = \$value;
 	my $nameint = "$namespace${key}_INT";
 	my $func = uc($key) . "_INT";
 	*{"$nameint"} = \&$func;
     }
 }
 
 sub new { 
 }
 
 sub to_priority {
     my($string) = @_;
 
     if(exists $PRIORITY{$string}) {
         return $PRIORITY{$string};
     }else{
         croak "level '$string' is not a valid error level (".join ('|', keys %PRIORITY),')';
     }
 }
 
 sub to_level {
     my ($priority) = @_;
     if (exists $LEVELS{$priority}) {
         return $LEVELS{$priority}
     }else {
       croak("priority '$priority' is not a valid error level number (",
 	  join("|", sort numerically keys %LEVELS), "
           )");
     }
 
 }
 
 sub to_LogDispatch_string {
     my($priority) = @_;
 
     confess "do what? no priority?" unless defined $priority;
 
     my $string;
 
     if(exists $LEVELS{$priority}) {
         $string = $LEVELS{$priority};
     }
 
     if($priority == $PRIORITY{WARN}) {
         $string = "WARNING";
     }
          
     if($priority == $PRIORITY{FATAL}) {
         $string = "EMERGENCY";
     }
          
     return $string;
 }
 
 sub is_valid {
     my $q = shift;
 
     if ($q =~ /[A-Z]/) {
         return exists $PRIORITY{$q};
     }else{
         return $LEVELS{$q};
     }
     
 }
 
 sub get_higher_level {
     my ($old_priority, $delta) = @_;
 
     $delta ||= 1;
 
     my $new_priority = 0;
 
     foreach (1..$delta){
         foreach my $p (sort numerically keys %LEVELS){
             if ($p > $old_priority) {
                 $new_priority = $p;
                 last;
             }
         }
         $old_priority = $new_priority;
     }
     return $new_priority;
 }
 
 sub get_lower_level {
     my ($old_priority, $delta) = @_;
 
     $delta ||= 1;
 
     my $new_priority = 0;
 
     foreach (1..$delta){
         foreach my $p (reverse sort numerically keys %LEVELS){
             if ($p < $old_priority) {
                 $new_priority = $p;
                 last;
             }
         }
         $old_priority = $new_priority;
     }
     return $new_priority;
 }
 
 sub isGreaterOrEqual {
   my $lval = shift;
   my $rval = shift;
   
 
   return $lval <= $rval;
 }
 
 
 
 1;
 
 __END__
 
### Log/Log4perl/Logger.pm ###
 package Log::Log4perl::Logger;
 
 use 5.006;
 use strict;
 use warnings;
 
 use Log::Log4perl;
 use Log::Log4perl::Level;
 use Log::Log4perl::Layout;
 use Log::Log4perl::Appender;
 use Log::Log4perl::Appender::String;
 use Log::Log4perl::Filter;
 use Carp;
 
 $Carp::Internal{"Log::Log4perl"}++;
 $Carp::Internal{"Log::Log4perl::Logger"}++;
 
 use constant _INTERNAL_DEBUG => 0;
 
 our $ROOT_LOGGER;
 our $LOGGERS_BY_NAME = {};
 our %APPENDER_BY_NAME = ();
 our $INITIALIZED = 0;
 our $NON_INIT_WARNED;
 our $DIE_DEBUG = 0;
 our $DIE_DEBUG_BUFFER = "";
 our $STRING_APP_NAME = "_l4p_warn";
 our $STRING_APP      = Log::Log4perl::Appender->new(
                           "Log::Log4perl::Appender::String",
                           name => $STRING_APP_NAME);
 $STRING_APP->layout(Log::Log4perl::Layout::PatternLayout->new("%m"));
 our $STRING_APP_CODEREF = generate_coderef([[$STRING_APP_NAME, $STRING_APP]]);
 
 __PACKAGE__->reset();
 
 sub warning_render {
     my($logger, @message) = @_;
 
     $STRING_APP->string("");
     $STRING_APP_CODEREF->($logger, 
                           @message, 
                           Log::Log4perl::Level::to_level($ALL));
     return $STRING_APP->string();
 }
 
 sub cleanup {
 
     Log::Log4perl->easy_closure_global_cleanup();
 
     $LOGGERS_BY_NAME = {};
 
     undef $ROOT_LOGGER;
 
     %APPENDER_BY_NAME   = ();
 
     undef $INITIALIZED;
 }
 
 sub DESTROY {
     CORE::warn "Destroying logger $_[0] ($_[0]->{category})" 
             if $Log::Log4perl::CHATTY_DESTROY_METHODS;
 }
 
 sub reset {
     $ROOT_LOGGER        = __PACKAGE__->_new("", $OFF);
 
     %APPENDER_BY_NAME   = ();
     undef $INITIALIZED;
     undef $NON_INIT_WARNED;
     Log::Log4perl::Appender::reset();
 
     foreach my $logger (values %$LOGGERS_BY_NAME){
         $logger->{appender_names} = [];
 
         next if $logger eq $ROOT_LOGGER;
         $logger->{level} = undef;
         $logger->level();  
     }
 
     Log::Log4perl::Filter::reset();
 }
 
 sub _new {
     my($class, $category, $level) = @_;
 
     print("_new: $class/$category/", defined $level ? $level : "undef",
           "\n") if _INTERNAL_DEBUG;
 
     die "usage: __PACKAGE__->_new(category)" unless
         defined $category;
     
     $category  =~ s/::/./g;
 
     if(exists $LOGGERS_BY_NAME->{$category}) {
         print "_new: exists already\n" if _INTERNAL_DEBUG;
         return $LOGGERS_BY_NAME->{$category};
     }
 
     my $self  = {
         category  => $category,
         num_appenders => 0,
         additivity    => 1,
         level         => $level,
         layout        => undef,
                 };
 
    bless $self, $class;
 
    $level ||= $self->level();
 
    $LOGGERS_BY_NAME->{$category} = $self;
 
    $self->set_output_methods;
 
    print("Created logger $self ($category)\n") if _INTERNAL_DEBUG;
 
    return $self;
 }
 
 sub category {
    my ($self) = @_;
 
    return $self->{ category };
 }
 
 sub reset_all_output_methods {
     print "reset_all_output_methods: \n" if _INTERNAL_DEBUG;
 
     foreach my $loggername ( keys %$LOGGERS_BY_NAME){
         $LOGGERS_BY_NAME->{$loggername}->set_output_methods;
     }
     $ROOT_LOGGER->set_output_methods;
 }
 
 sub set_output_methods {
    my ($self) = @_;
     
    my (@appenders, %seen);
 
    my ($level) = $self->level();
 
    print "set_output_methods: $self->{category}/$level\n" if _INTERNAL_DEBUG;
 
 
    for(my $logger = $self; $logger; $logger = parent_logger($logger)) {
 
         foreach my $appender_name (@{$logger->{appender_names}}){
 
             next if $seen{$appender_name} ++ && 
                     $Log::Log4perl::one_message_per_appender;
 
             push (@appenders,     
                    [$appender_name,
                     $APPENDER_BY_NAME{$appender_name},
                    ]
             );
         }
         last unless $logger->{additivity};
     }
 
     my $noop = generate_noop_coderef();
 
     my $coderef = (! @appenders ? $noop : &generate_coderef(\@appenders)); 
 
     my %priority = %Log::Log4perl::Level::PRIORITY; 
 
     foreach my $levelname (keys %priority){
         if (Log::Log4perl::Level::isGreaterOrEqual($level,
 						   $priority{$levelname}
 						   )) {
             print "  ($priority{$levelname} <= $level)\n"
                   if _INTERNAL_DEBUG;
             $self->{$levelname}      = $coderef;
             $self->{"is_$levelname"} = generate_is_xxx_coderef("1");
             print "Setting is_$levelname to 1\n" if _INTERNAL_DEBUG;
         }else{
             print "  ($priority{$levelname} > $level)\n" if _INTERNAL_DEBUG;
             $self->{$levelname}      = $noop;
             $self->{"is_$levelname"} = generate_is_xxx_coderef("0");
             print "Setting is_$levelname to 0\n" if _INTERNAL_DEBUG;
         }
 
         print("  Setting [$self] $self->{category}.$levelname to ",
               ($self->{$levelname} == $noop ? "NOOP" : 
               ("Coderef [$coderef]: " . scalar @appenders . " appenders")), 
               "\n") if _INTERNAL_DEBUG;
     }
 }
 
 sub generate_coderef {
     my $appenders = shift;
                     
     print "generate_coderef: ", scalar @$appenders, 
           " appenders\n" if _INTERNAL_DEBUG;
 
     my $watch_check_code = generate_watch_code("logger", 1);
 
     return sub {
       my $logger = shift;
       my $level  = pop;
 
       my $message;
       my $appenders_fired = 0;
       
 
       $message   = [map { ref $_ eq "HASH" && 
                            exists $_->{filter} && 
                            ref $_->{filter} eq 'CODE' ?
                                $_->{filter}->($_->{value}) :
                            ref $_ eq "CODE" ?
                                $_->() : $_ 
                           } @_];                  
 
       print("coderef: $logger->{category}\n") if _INTERNAL_DEBUG;
 
       if(defined $Log::Log4perl::Config::WATCHER) {
           return unless $watch_check_code->($logger, @_, $level);
       }
 
       foreach my $a (@$appenders) {   
           my ($appender_name, $appender) = @$a;
 
           print("  Sending message '<$message->[0]>' ($level) " .
                 "to $appender_name\n") if _INTERNAL_DEBUG;
                 
           $appender->log(
               { name    => $appender_name,
                 level   => $Log::Log4perl::Level::L4P_TO_LD{
                                $level},   
                 message => $message,
               },
               $logger->{category},
               $level,
           ) and $appenders_fired++;
     
       } 
     
       return $appenders_fired;
 
     }; 
 }
 
 sub generate_noop_coderef {
     my $watch_delay_code;
 
 
     my $watch_check_code = generate_watch_code("logger", 1);
 
     my $coderef;
 
     if(defined $Log::Log4perl::Config::WATCHER) {
         $coderef = $watch_check_code;
     } else {
         $coderef = sub { undef };
     }
 
     return $coderef;
 }
 
 sub generate_is_xxx_coderef {
     my($return_token) = @_;
 
     return generate_watch_code("checker", $return_token);
 }
 
 sub generate_watch_code {
     my($type, $return_token) = @_;
 
     print "generate_watch_code:\n" if _INTERNAL_DEBUG;
 
     if(! defined $Log::Log4perl::Config::WATCHER) {
         return sub { $return_token };
     }
 
     my $cond = generate_watch_conditional();
 
     return sub {
         print "exe_watch_code:\n" if _INTERNAL_DEBUG;
 
        if(_INTERNAL_DEBUG) {
            print "Next check: ",
              "$Log::Log4perl::Config::Watch::NEXT_CHECK_TIME ",
              " Now: ", time(), " Mod: ",
              (stat($Log::Log4perl::Config::WATCHER->file()))[9],
              "\n";
        }
 
        if( $cond->() ) {
            my $init_permitted = 1;
 
            if(exists $Log::Log4perl::Config::OPTS->{ preinit_callback } ) {
                print "Calling preinit_callback\n" if _INTERNAL_DEBUG;
                $init_permitted = 
                $Log::Log4perl::Config::OPTS->{ preinit_callback }->( 
                    Log::Log4perl::Config->watcher()->file() );
                print "Callback returned $init_permitted\n" if _INTERNAL_DEBUG;
            }
 
            if( $init_permitted ) {
                Log::Log4perl->init_and_watch();
            } else {
                return 1;
            }
 
            my $logger = shift;
            my $level  = pop;
 
            if($type eq "checker") {
                return $logger->$level();
 
            } elsif( $type eq "logger") {
                my $methodname = lc($level);
 
                local $Log::Log4perl::caller_depth =
                      $Log::Log4perl::caller_depth + 3;
 
                $logger = Log::Log4perl::get_logger( $logger->{category} );
 
                $logger->$methodname(@_); 
                return undef;     
            } else {
                die "internal error: unknown type";
            }
        } else {
            if(_INTERNAL_DEBUG) {
                print "Conditional returned false\n";
            }
            return $return_token;
        }
    };
 }
 
 sub generate_watch_conditional {
 
     if(defined $Log::Log4perl::Config::Watch::SIGNAL_CAUGHT) {
         return sub {
             return $Log::Log4perl::Config::Watch::SIGNAL_CAUGHT;
         };
     }
 
     return sub {
         return 
             ( time() > $Log::Log4perl::Config::Watch::NEXT_CHECK_TIME and 
               $Log::Log4perl::Config::WATCHER->change_detected() );
     };
 }
 
 sub parent_string {
     my($string) = @_;
 
     if($string eq "") {
         return undef; 
     }
 
     my @components = split /\./, $string;
     
     if(@components == 1) {
         return "";
     }
 
     pop @components;
 
     return join('.', @components);
 }
 
 sub level {
     my($self, $level, $dont_reset_all) = @_;
 
     if(defined $level) {
         croak "invalid level '$level'" 
                 unless Log::Log4perl::Level::is_valid($level);
         if ($level =~ /\D/){
             $level = Log::Log4perl::Level::to_priority($level);
         }
         $self->{level} = $level;   
 
         &reset_all_output_methods
             unless $dont_reset_all;  
 
         return $level;
     }
 
     if(defined $self->{level}) {
         return $self->{level};
     }
 
     for(my $logger = $self; $logger; $logger = parent_logger($logger)) {
 
 
         if($logger->{category} eq "") {
             return $ROOT_LOGGER->{level};
         }
             
         if(defined $LOGGERS_BY_NAME->{$logger->{category}}->{level}) {
             return $LOGGERS_BY_NAME->{$logger->{category}}->{level};
         }
     }
 
     die "We should never get here.";
 }
 
 sub parent_logger {
     my($logger) = @_;
 
     if($logger->{category} eq "") {
         return undef;
     }
 
     my $parent_class = parent_string($logger->{category});
 
     while($parent_class ne "" and
           ! exists $LOGGERS_BY_NAME->{$parent_class}) {
         $parent_class = parent_string($parent_class);
         $logger =  $LOGGERS_BY_NAME->{$parent_class};
     }
 
     if($parent_class eq "") {
         $logger = $ROOT_LOGGER;
     } else {
         $logger = $LOGGERS_BY_NAME->{$parent_class};
     }
 
     return $logger;
 }
 
 sub get_root_logger {
     my($class) = @_;
     return $ROOT_LOGGER;    
 }
 
 sub additivity {
     my($self, $onoff, $no_reinit) = @_;
 
     if(defined $onoff) {
         $self->{additivity} = $onoff;
     }
 
     if( ! $no_reinit ) {
         $self->set_output_methods();
     }
 
     return $self->{additivity};
 }
 
 sub get_logger {
     my($class, $category) = @_;
 
     unless(defined $ROOT_LOGGER) {
         Carp::confess "Internal error: Root Logger not initialized.";
     }
 
     return $ROOT_LOGGER if $category eq "";
 
     my $logger = $class->_new($category);
     return $logger;
 }
 
 sub add_appender {
     my($self, $appender, $dont_reset_all) = @_;
 
     $INITIALIZED = 1;
 
     my $appender_name = $appender->name();
 
     $self->{num_appenders}++;  
 
     unless (grep{$_ eq $appender_name} @{$self->{appender_names}}){
         $self->{appender_names} = [sort @{$self->{appender_names}}, 
                                         $appender_name];
     }
 
     $APPENDER_BY_NAME{$appender_name} = $appender;
 
     reset_all_output_methods
                 unless $dont_reset_all;  
 
     return $appender;
 }
 
 sub remove_appender {
     my($self, $appender_name, $dont_reset_all, $sloppy) = @_;
 
     my %appender_names = map { $_ => 1 } @{$self->{appender_names}};
     
     if(!exists $appender_names{$appender_name}) {
         die "No such appender: $appender_name" unless $sloppy;
         return undef;
     }
 
     delete $appender_names{$appender_name};
     $self->{num_appenders}--;
     $self->{appender_names} = [sort keys %appender_names];
 
     &reset_all_output_methods
                 unless $dont_reset_all; 
 }
 
 sub eradicate_appender {
     shift if $_[0] eq __PACKAGE__;
 
     my($appender_name, $dont_reset_all) = @_;
 
     return 0 unless exists 
         $APPENDER_BY_NAME{$appender_name};
 
     foreach my $logger (values %$LOGGERS_BY_NAME){
         $logger->remove_appender($appender_name, 0, 1);
     }
     $ROOT_LOGGER->remove_appender($appender_name, 0, 1);
     
     delete $APPENDER_BY_NAME{$appender_name};
 
     &reset_all_output_methods
                 unless $dont_reset_all; 
 
     return 1;
 }
 
 sub has_appenders {
     my($self) = @_;
 
     return $self->{num_appenders};
 }
 
 sub log {
     my ($self, $priority, @messages) = @_;
 
     confess("log: No priority given!") unless defined($priority);
 
     $_[0] = $LOGGERS_BY_NAME->{$_[0]->{category}} if 
         defined $Log::Log4perl::Config::WATCHER;
 
     init_warn() unless $INITIALIZED or $NON_INIT_WARNED;
 
     croak "priority $priority isn't numeric" if ($priority =~ /\D/);
 
     my $which = Log::Log4perl::Level::to_level($priority);
 
     $self->{$which}->($self, @messages, 
                     Log::Log4perl::Level::to_level($priority));
 }
 
 sub create_custom_level {
   my $level = shift || die("create_custom_level: " .
                            "forgot to pass in a level string!");
   my $after = shift || die("create_custom_level: " .
                            "forgot to pass in a level after which to " .
                            "place the new level!");
   my $syslog_equiv = shift; 
   my $log_dispatch_level = shift; 
 
 
   die("create_custom_level must be called before init or " .
       "first get_logger() call") if ($INITIALIZED);
 
   my %PRIORITY = %Log::Log4perl::Level::PRIORITY; 
 
   die("create_custom_level: no such level \"$after\"! Use one of: ", 
      join(", ", sort keys %PRIORITY)) unless $PRIORITY{$after};
 
 
   my $next_prio = Log::Log4perl::Level::get_lower_level($PRIORITY{$after}, 1);
   my $cust_prio = int(($PRIORITY{$after} + $next_prio) / 2);
 
   die(qq{create_custom_level: Calculated level of $cust_prio already exists!
       This should only happen if you've made some insane number of custom
       levels (like 15 one after another)
       You can usually fix this by re-arranging your code from:
       create_custom_level("cust1", X);
       create_custom_level("cust2", X);
       create_custom_level("cust3", X);
       create_custom_level("cust4", X);
       create_custom_level("cust5", X);
       into:
       create_custom_level("cust3", X);
       create_custom_level("cust5", X);
       create_custom_level("cust4", 4);
       create_custom_level("cust2", cust3);
       create_custom_level("cust1", cust2);
    }) if (${Log::Log4perl::Level::LEVELS{$cust_prio}});
 
   Log::Log4perl::Level::add_priority($level, $cust_prio, $syslog_equiv,
                                      $log_dispatch_level);
 
   print("Adding prio $level at $cust_prio\n") if _INTERNAL_DEBUG;
 
   my $name = "Log::Log4perl::Logger::";
   my $key = $level;
 
   no strict qw(refs);
   *{"$name$key"} = \${Log::Log4perl::Level::PRIORITY{$level}};
 
   $name = caller(0) . "::";
   *{"$name$key"} = \${Log::Log4perl::Level::PRIORITY{$level}};
   use strict qw(refs);
 
   create_log_level_methods($level);
 
   return 0;
 
 }
 
 sub create_log_level_methods {
   my $level = shift || die("create_log_level_methods: " .
                            "forgot to pass in a level string!");
   my $lclevel = lc($level);
   my $levelint = uc($level) . "_INT";
   my $initial_cap = ucfirst($lclevel);
 
   no strict qw(refs);
 
 
   *{__PACKAGE__ . "::$lclevel"} = sub {
         if(_INTERNAL_DEBUG) {
             my $level_disp = (defined $_[0]->{level} ? $_[0]->{level} 
                                                      : "[undef]");
             print "$lclevel: ($_[0]->{category}/$level_disp) [@_]\n";
         }
         init_warn() unless $INITIALIZED or $NON_INIT_WARNED;
         $_[0]->{$level}->(@_, $level) if defined $_[0]->{$level};
      };
 
   
   my $islevel   = "is_" . $level;
   my $islclevel = "is_" . $lclevel;
 
   *{__PACKAGE__ . "::is_$lclevel"} = sub {
       $_[0]->{$islevel}->($_[0], $islclevel);
   };
   
   
   *{__PACKAGE__ . "::is".$initial_cap."Enabled"} = 
                            \&{__PACKAGE__ . "::is_$lclevel"};
   
   use strict qw(refs);
 
   return 0;
 }
 
 foreach my $level (keys %Log::Log4perl::Level::PRIORITY){
   create_log_level_methods($level);
 }
 
 sub init_warn {
     CORE::warn "Log4perl: Seems like no initialization happened. " .
                "Forgot to call init()?\n";
     $NON_INIT_WARNED = 1;
 }
 
 sub callerline {
   my $message = join ('', @_);
 
   my $caller_offset = 
     Log::Log4perl::caller_depth_offset( 
         $Log::Log4perl::caller_depth + 1 );
 
   my ($pack, $file, $line) = caller($caller_offset);
 
   if (not chomp $message) {     
     $message .= " at $file line $line";
 
     if (defined &Thread::tid) {
       my $tid = Thread->self->tid;
       $message .= " thread $tid" if $tid;
     }
   }
 
   return ($message, "\n");
 }
 
 sub and_warn {
   my $self = shift;
   CORE::warn(callerline($self->warning_render(@_)));
 }
 
 sub and_die {
   my $self = shift;
   my $arg  = $_[0];
 
   my($msg) = callerline($self->warning_render(@_));
 
   if($DIE_DEBUG) {
       $DIE_DEBUG_BUFFER = "DIE_DEBUG: $msg";
   } else {
       if( $Log::Log4perl::STRINGIFY_DIE_MESSAGE ) {
           die("$msg\n");
       }
       die $arg;
   }
 }
 
 sub logwarn {
   my $self = shift;
 
   local $Log::Log4perl::caller_depth = 
         $Log::Log4perl::caller_depth + 1;
 
   if ($self->is_warn()) {
     my @chomped = @_;
     chomp($chomped[-1]);
     $self->warn(@chomped);
   }
 
   $self->and_warn(@_);
 }
 
 sub logdie {
   my $self = shift;
 
   local $Log::Log4perl::caller_depth = 
         $Log::Log4perl::caller_depth + 1;
 
   if ($self->is_fatal()) {
     my @chomped = @_;
     chomp($chomped[-1]);
     $self->fatal(@chomped);
   }
 
   $Log::Log4perl::LOGDIE_MESSAGE_ON_STDERR ? 
       $self->and_die(@_) : 
         exit($Log::Log4perl::LOGEXIT_CODE);
 }
 
 sub logexit {
   my $self = shift;
 
   local $Log::Log4perl::caller_depth = 
         $Log::Log4perl::caller_depth + 1;
 
   if ($self->is_fatal()) {
     my @chomped = @_;
     chomp($chomped[-1]);
     $self->fatal(@chomped);
   }
 
   exit $Log::Log4perl::LOGEXIT_CODE;
 }
 
 sub logcluck {
   my $self = shift;
 
   local $Log::Log4perl::caller_depth = 
         $Log::Log4perl::caller_depth + 1;
 
   local $Carp::CarpLevel = 
         $Carp::CarpLevel + 1;
 
   my $msg = $self->warning_render(@_);
 
   if ($self->is_warn()) {
     my $message = Carp::longmess($msg);
     foreach (split(/\n/, $message)) {
       $self->warn("$_\n");
     }
   }
 
   Carp::cluck($msg);
 }
 
 sub logcarp {
   my $self = shift;
 
   local $Carp::CarpLevel = $Carp::CarpLevel + 1;
 
   local $Log::Log4perl::caller_depth = 
         $Log::Log4perl::caller_depth + 1;
 
   my $msg = $self->warning_render(@_);
 
   if ($self->is_warn()) {
     my $message = Carp::shortmess($msg);
     foreach (split(/\n/, $message)) {
       $self->warn("$_\n");
     }
   }
 
   Carp::carp($msg);
 }
 
 sub logcroak {
   my $self = shift;
   my $arg  = $_[0];
 
   my $msg = $self->warning_render(@_);
 
   local $Carp::CarpLevel = 
         $Carp::CarpLevel + 1;
 
   local $Log::Log4perl::caller_depth = 
         $Log::Log4perl::caller_depth + 1;
 
   if ($self->is_fatal()) {
     my $message = Carp::shortmess($msg);
     foreach (split(/\n/, $message)) {
       $self->fatal("$_\n");
     }
   }
 
   my $croak_msg = $arg;
 
   if( $Log::Log4perl::STRINGIFY_DIE_MESSAGE ) {
       $croak_msg = $msg;
   }
 
   $Log::Log4perl::LOGDIE_MESSAGE_ON_STDERR ? 
       Carp::croak($croak_msg) : 
         exit($Log::Log4perl::LOGEXIT_CODE);
 }
 
 sub logconfess {
   my $self = shift;
   my $arg  = $_[0];
 
   local $Carp::CarpLevel = 
         $Carp::CarpLevel + 1;
 
   local $Log::Log4perl::caller_depth = 
         $Log::Log4perl::caller_depth + 1;
 
   my $msg = $self->warning_render(@_);
 
   if ($self->is_fatal()) {
     my $message = Carp::longmess($msg);
     foreach (split(/\n/, $message)) {
       $self->fatal("$_\n");
     }
   }
 
   my $confess_msg = $arg;
 
   if( $Log::Log4perl::STRINGIFY_DIE_MESSAGE ) {
       $confess_msg = $msg;
   }
 
   $Log::Log4perl::LOGDIE_MESSAGE_ON_STDERR ? 
       confess($confess_msg) :
         exit($Log::Log4perl::LOGEXIT_CODE);
 }
 
 sub error_warn {
   my $self = shift;
 
   local $Log::Log4perl::caller_depth = 
         $Log::Log4perl::caller_depth + 1;
 
   if ($self->is_error()) {
     $self->error(@_);
   }
 
   $self->and_warn(@_);
 }
 
 sub error_die {
   my $self = shift;
 
   local $Log::Log4perl::caller_depth = 
         $Log::Log4perl::caller_depth + 1;
 
   my $msg = $self->warning_render(@_);
 
   if ($self->is_error()) {
     $self->error($msg);
   }
 
   $Log::Log4perl::LOGDIE_MESSAGE_ON_STDERR ? 
       $self->and_die($msg) :
         exit($Log::Log4perl::LOGEXIT_CODE);
 }
 
 sub more_logging {
   my ($self) = shift;
   return $self->dec_level(@_);
 }
 
 sub inc_level {
     my ($self, $delta) = @_;
 
     $delta ||= 1;
 
     $self->level(Log::Log4perl::Level::get_higher_level($self->level(), 
                                                         $delta));
 
     $self->set_output_methods;
 }
 
 sub less_logging {
   my ($self) = shift;
   return $self->inc_level(@_);
 }
 
 sub dec_level {
     my ($self, $delta) = @_;
 
     $delta ||= 1;
 
     $self->level(Log::Log4perl::Level::get_lower_level($self->level(), $delta));
 
     $self->set_output_methods;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/MDC.pm ###
 package Log::Log4perl::MDC;
 
 use 5.006;
 use strict;
 use warnings;
 
 our %MDC_HASH = ();
 
 sub get {
     my($class, $key) = @_;
 
     if($class ne __PACKAGE__) {
         $key = $class;
     }
 
     if(exists $MDC_HASH{$key}) {
         return $MDC_HASH{$key};
     } else {
         return undef;
     }
 }
 
 sub put {
     my($class, $key, $value) = @_;
 
     if($class ne __PACKAGE__) {
         $value = $key;
         $key   = $class;
     }
 
     $MDC_HASH{$key} = $value;
 }
 
 sub remove {
     %MDC_HASH = ();
 
     1;
 }
 
 sub get_context {
     return \%MDC_HASH;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/NDC.pm ###
 package Log::Log4perl::NDC;
 
 use 5.006;
 use strict;
 use warnings;
 
 our @NDC_STACK = ();
 our $MAX_SIZE  = 5;
 
 sub get {
     if(@NDC_STACK) {
         return join " ", @NDC_STACK;
     } else {
         return "[undef]";
     }
 }
 
 sub pop {
     if(@NDC_STACK) {
         return pop @NDC_STACK;
     } else {
         return undef;
     }
 }
 
 sub push {
     my($self, $text) = @_;
 
     unless(defined $text) {
         $text = $self;
     }
 
     if(@NDC_STACK >= $MAX_SIZE) {
         CORE::pop(@NDC_STACK);
     }
 
     return push @NDC_STACK, $text;
 }
 
 sub remove {
     @NDC_STACK = ();
 }
 
 __END__
 
### Log/Log4perl/Resurrector.pm ###
 package Log::Log4perl::Resurrector;
 use warnings;
 use strict;
 
 use if $^O eq "MSWin32", "Win32"; 
 
 use File::Temp qw(tempfile);
 use File::Spec;
 
 use constant INTERNAL_DEBUG => 0;
 
 our $resurrecting = '';
 
 sub import {
     resurrector_init();
 }
 
 sub resurrector_fh {
     my($file) = @_;
 
     local($/) = undef;
     open FILE, "<$file" or die "Cannot open $file";
     my $text = <FILE>;
     close FILE;
 
     print "Read ", length($text), " bytes from $file\n" if INTERNAL_DEBUG;
 
     my($tmp_fh, $tmpfile) = tempfile( UNLINK => 1 );
     print "Opened tmpfile $tmpfile\n" if INTERNAL_DEBUG;
 
     $text =~ s/^\s*###l4p//mg;
 
     print "Text=[$text]\n" if INTERNAL_DEBUG;
 
     print $tmp_fh $text;
     seek $tmp_fh, 0, 0;
 
     return $tmp_fh;
 }
 
 sub resurrector_loader {
     my ($code, $module) = @_;
 
     print "resurrector_loader called with $module\n" if INTERNAL_DEBUG;
 
     if($resurrecting eq $module) {
         print "ignoring $module (recursion)\n" if INTERNAL_DEBUG;
         return undef;
     }
     
     local $resurrecting = $module;
     
     
     if($module =~ m#^Log/Log4perl/Appender#) {
         print "Ignoring $module (Log4perl-internal)\n" if INTERNAL_DEBUG;
         return undef;
     }
 
     my $path = $module;
 
     if(!-f $module) {
         $path = pm_search($module);
         if(! defined $path) {
             print "File $module not found\n" if INTERNAL_DEBUG;
             return undef;
         }
         print "File $module found in $path\n" if INTERNAL_DEBUG;
     }
 
     print "Resurrecting module $path\n" if INTERNAL_DEBUG;
 
     my $fh = resurrector_fh($path);
 
     my $abs_path = File::Spec->rel2abs( $path );
     print "Setting %INC entry of $module to $abs_path\n" if INTERNAL_DEBUG;
     $INC{$module} = $abs_path;
 
     return $fh;
 }
 
 sub pm_search {
     my($pmfile) = @_;
 
     for(@INC) {
         next if ref($_);
         my $path = File::Spec->catfile($_, $pmfile);
         return $path if -f $path;
     }
 
     return undef;
 }
 
 sub resurrector_init {
     unshift @INC, \&resurrector_loader;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Util.pm ###
 package Log::Log4perl::Util;
 
 require Exporter;
 our @EXPORT_OK = qw( params_check );
 our @ISA       = qw( Exporter );
 
 use File::Spec;
 
 sub params_check {
     my( $hash, $required, $optional ) = @_;
 
     my $pkg       = caller();
     my %hash_copy = %$hash;
 
     if( defined $required ) {
         for my $p ( @$required ) {
             if( !exists $hash->{ $p } or
                 !defined $hash->{ $p } ) {
                 die "$pkg: Required parameter $p missing.";
             }
             delete $hash_copy{ $p };
         }
     }
 
     if( defined $optional ) {
         for my $p ( @$optional ) {
             delete $hash_copy{ $p };
         }
         if( scalar keys %hash_copy ) {
             die "$pkg: Unknown parameter: ", join( ",", keys %hash_copy );
         }
     }
 }
 
 sub module_available {  
     my($full_name) = @_;
 
     return 0 if $full_name =~ /[^\w:]/;
 
     local $SIG{__DIE__} = sub {};
 
     eval "require $full_name";
 
     if($@) {
         return 0;
     }
 
     return 1;
 }
 
 sub tmpfile_name {  
 
     my $name = File::Spec->catfile(File::Spec->tmpdir(), 
                               'l4p-tmpfile-' . 
                               "$$-" .
                               int(rand(9999999)));
 
     $name =~ s#\\#/#g;
     return $name;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Util/Semaphore.pm ###
 package Log::Log4perl::Util::Semaphore;
 use IPC::SysV qw(IPC_RMID IPC_CREAT IPC_EXCL SEM_UNDO IPC_NOWAIT 
                  IPC_SET IPC_STAT SETVAL);
 use IPC::Semaphore;
 use POSIX qw(EEXIST);
 use strict;
 use warnings;
 use constant INTERNAL_DEBUG => 0;
 
 sub new {
     my($class, %options) = @_;
 
     my $self = {
         key           => undef,
         mode          => undef,
         uid           => undef,
         gid           => undef,
         destroy       => undef,
         semop_wait    => .1,
         semop_retries => 1,
 	creator       => $$,
         %options,
     };
 
     $self->{ikey} = unpack("i", pack("A4", $self->{key}));
 
     if(defined $self->{uid} and 
        $self->{uid} =~ /\D/) {
         $self->{uid} = (getpwnam $self->{uid})[2];
     }
 
     bless $self, $class;
     $self->init();
 
     my @values = ();
     for my $param (qw(mode uid gid)) {
         push @values, $param, $self->{$param} if defined $self->{$param};
     }
     $self->semset(@values) if @values;
 
     return $self;
 }
 
 sub init {
     my($self) = @_;
 
     print "Semaphore init '$self->{key}'/'$self->{ikey}'\n" if INTERNAL_DEBUG;
 
     $self->{id} = semget( $self->{ikey}, 
                           1, 
                           &IPC_EXCL|&IPC_CREAT|($self->{mode}||0777),
                   );
    
    if(! defined $self->{id} and
       $! == EEXIST) {
        print "Semaphore '$self->{key}' already exists\n" if INTERNAL_DEBUG;
        $self->{id} = semget( $self->{ikey}, 1, 0 )
            or die "semget($self->{ikey}) failed: $!";
    } elsif($!) {
        die "Cannot create semaphore $self->{key}/$self->{ikey} ($!)";
    }
 }
 
 sub status_as_string {
     my($self, @values) = @_;
 
     my $sem = IPC::Semaphore->new($self->{ikey}, 1, 0);
 
     my $values  = join('/', $sem->getall());
     my $ncnt    = $sem->getncnt(0);
     my $pidlast = $sem->getpid(0);
     my $zcnt    = $sem->getzcnt(0);
     my $id      = $sem->id();
 
     return <<EOT;
 Semaphore Status
 Key ...................................... $self->{key}
 iKey ..................................... $self->{ikey}
 Id ....................................... $id
 Values ................................... $values
 Processes waiting for counter increase ... $ncnt
 Processes waiting for counter to hit 0 ... $zcnt
 Last process to perform an operation ..... $pidlast
 EOT
 }
 
 sub semsetval {
     my($self, %keyvalues) = @_;
 
     my $sem = IPC::Semaphore->new($self->{ikey}, 1, 0);
     $sem->setval(%keyvalues);
 }
 
 sub semset {
     my($self, @values) = @_;
 
     print "Setting values for semaphore $self->{key}/$self->{ikey}\n" if
         INTERNAL_DEBUG;
 
     my $sem = IPC::Semaphore->new($self->{ikey}, 1, 0);
     $sem->set(@values);
 }
 
 sub semlock {
     my($self) = @_;
 
     my $operation = pack("s!*", 
                          0, 0, 0,
                          0, 1, SEM_UNDO
                         );
 
     print "Locking semaphore '$self->{key}'\n" if INTERNAL_DEBUG;
     $self->semop($self->{id}, $operation);
 }
 
 sub semunlock {
     my($self) = @_;
 
     print "Unlocking semaphore '$self->{key}'\n" if INTERNAL_DEBUG;
 
 
     semctl $self->{id}, 0, SETVAL, 0;
 }
 
 sub remove {
     my($self) = @_;
 
     print "Removing semaphore '$self->{key}'\n" if INTERNAL_DEBUG;
 
     semctl ($self->{id}, 0, &IPC_RMID, 0) or 
         die "Removing semaphore $self->{key} failed: $!";
 }
 
 sub DESTROY {
     my($self) = @_;
 
     if($self->{destroy} && $$==$self->{creator}) {
         $self->remove();
     }
 }
 
 sub semop {
     my($self, @args) = @_;
 
     my $retries     = $self->{semop_retries};
 
     my $rc;
 
     {
         $rc = semop($args[0], $args[1]);
 
         if(!$rc and 
            $! =~ /temporarily unavailable/ and
            $retries-- > 0) {
             $rc = 'undef' unless defined $rc;
             print "semop failed (rc=$rc), retrying\n", 
                   $self->status_as_string if INTERNAL_DEBUG;
             select undef, undef, undef, $self->{semop_wait};
             redo;
         }
     }
 
     $rc or die "semop(@args) failed: $! ";
     $rc;
 }
 
 1;
 
 __END__
 
### Log/Log4perl/Util/TimeTracker.pm ###
 package Log::Log4perl::Util::TimeTracker;
 
 use 5.006;
 use strict;
 use warnings;
 use Log::Log4perl::Util;
 use Carp;
 
 our $TIME_HIRES_AVAILABLE;
 
 BEGIN {
     $TIME_HIRES_AVAILABLE = 0;
     if(Log::Log4perl::Util::module_available("Time::HiRes")) {
         require Time::HiRes;
         $TIME_HIRES_AVAILABLE = 1;
     }
 }
 
 sub new {
     my $class = shift;
     $class = ref ($class) || $class;
 
     my $self = {
         reset_time            => undef,
         @_,
     };
 
     $self->{time_function} = \&_gettimeofday unless 
         defined $self->{time_function};
 
     bless $self, $class;
 
     $self->reset();
 
     return $self;
 }
 
 sub hires_available {
     return $TIME_HIRES_AVAILABLE;
 }
 
 sub _gettimeofday {
     if($TIME_HIRES_AVAILABLE) {
         return (Time::HiRes::gettimeofday());
     } else {
         return (time(), 0);
     }
 }
 
 sub gettimeofday {
     my($self) = @_;
 
     my($seconds, $microseconds) = $self->{time_function}->();
 
     $microseconds = 0 if ! defined $microseconds;
     return($seconds, $microseconds);
 }
 
 sub reset {
     my($self) = @_;
 
     my $current_time = [$self->gettimeofday()];
     $self->{reset_time} = $current_time;
     $self->{last_call_time} = $current_time;
 
     return $current_time;
 }
 
 sub time_diff {
     my($time_from, $time_to) = @_;
 
     my $seconds = $time_to->[0] -
                   $time_from->[0];
 
     my $milliseconds = int(( $time_to->[1] -
                              $time_from->[1] ) / 1000);
 
     if($milliseconds < 0) {
         $milliseconds = 1000 + $milliseconds;
         $seconds--;
     }
 
     return($seconds, $milliseconds);
 }
 
 sub milliseconds {
     my($self, $current_time) = @_;
 
     $current_time = [ $self->gettimeofday() ] unless
         defined $current_time;
 
     my($seconds, $milliseconds) = time_diff(
             $self->{reset_time}, 
             $current_time);
 
     return $seconds*1000 + $milliseconds;
 }
 
 sub delta_milliseconds {
     my($self, $current_time) = @_;
 
     $current_time = [ $self->gettimeofday() ] unless
         defined $current_time;
 
     my($seconds, $milliseconds) = time_diff(
             $self->{last_call_time}, 
             $current_time);
 
     $self->{last_call_time} = $current_time;
 
     return $seconds*1000 + $milliseconds;
 }
 
 1;
 
 __END__
 
### Method/Generate/Accessor.pm ###
 package Method::Generate::Accessor;
 
 use Moo::_strictures;
 use Moo::_Utils;
 use Moo::Object ();
 our @ISA = qw(Moo::Object);
 use Sub::Quote qw(quote_sub quoted_from_sub quotify);
 use Scalar::Util 'blessed';
 use overload ();
 use Module::Runtime qw(use_module);
 BEGIN {
   our $CAN_HAZ_XS =
     !$ENV{MOO_XS_DISABLE}
       &&
     _maybe_load_module('Class::XSAccessor')
       &&
     (eval { Class::XSAccessor->VERSION('1.07') })
   ;
   our $CAN_HAZ_XS_PRED =
     $CAN_HAZ_XS &&
     (eval { Class::XSAccessor->VERSION('1.17') })
   ;
 }
 
 my $module_name_only = qr/\A$Module::Runtime::module_name_rx\z/;
 
 sub _die_overwrite
 {
   my ($pkg, $method, $type) = @_;
   die "You cannot overwrite a locally defined method ($method) with "
     . ( $type || 'an accessor' );
 }
 
 sub generate_method {
   my ($self, $into, $name, $spec, $quote_opts) = @_;
   $spec->{allow_overwrite}++ if $name =~ s/^\+//;
   die "Must have an is" unless my $is = $spec->{is};
   if ($is eq 'ro') {
     $spec->{reader} = $name unless exists $spec->{reader};
   } elsif ($is eq 'rw') {
     $spec->{accessor} = $name unless exists $spec->{accessor}
       or ( $spec->{reader} and $spec->{writer} );
   } elsif ($is eq 'lazy') {
     $spec->{reader} = $name unless exists $spec->{reader};
     $spec->{lazy} = 1;
     $spec->{builder} ||= '_build_'.$name unless exists $spec->{default};
   } elsif ($is eq 'rwp') {
     $spec->{reader} = $name unless exists $spec->{reader};
     $spec->{writer} = "_set_${name}" unless exists $spec->{writer};
   } elsif ($is ne 'bare') {
     die "Unknown is ${is}";
   }
   if (exists $spec->{builder}) {
     if(ref $spec->{builder}) {
       $self->_validate_codulatable('builder', $spec->{builder},
         "$into->$name", 'or a method name');
       $spec->{builder_sub} = $spec->{builder};
       $spec->{builder} = 1;
     }
     $spec->{builder} = '_build_'.$name if ($spec->{builder}||0) eq 1;
     die "Invalid builder for $into->$name - not a valid method name"
       if $spec->{builder} !~ $module_name_only;
   }
   if (($spec->{predicate}||0) eq 1) {
     $spec->{predicate} = $name =~ /^_/ ? "_has${name}" : "has_${name}";
   }
   if (($spec->{clearer}||0) eq 1) {
     $spec->{clearer} = $name =~ /^_/ ? "_clear${name}" : "clear_${name}";
   }
   if (($spec->{trigger}||0) eq 1) {
     $spec->{trigger} = quote_sub('shift->_trigger_'.$name.'(@_)');
   }
   if (($spec->{coerce}||0) eq 1) {
     my $isa = $spec->{isa};
     if (blessed $isa and $isa->can('coercion')) {
       $spec->{coerce} = $isa->coercion;
     } elsif (blessed $isa and $isa->can('coerce')) {
       $spec->{coerce} = sub { $isa->coerce(@_) };
     } else {
       die "Invalid coercion for $into->$name - no appropriate type constraint";
     }
   }
 
   foreach my $setting (qw( isa coerce )) {
     next if !exists $spec->{$setting};
     $self->_validate_codulatable($setting, $spec->{$setting}, "$into->$name");
   }
 
   if (exists $spec->{default}) {
     if (ref $spec->{default}) {
       $self->_validate_codulatable('default', $spec->{default}, "$into->$name",
         'or a non-ref');
     }
   }
 
   if (exists $spec->{moosify}) {
     if (ref $spec->{moosify} ne 'ARRAY') {
       $spec->{moosify} = [$spec->{moosify}];
     }
 
     foreach my $spec (@{$spec->{moosify}}) {
       $self->_validate_codulatable('moosify', $spec, "$into->$name");
     }
   }
 
   my %methods;
   if (my $reader = $spec->{reader}) {
     _die_overwrite($into, $reader, 'a reader')
       if !$spec->{allow_overwrite} && defined &{"${into}::${reader}"};
     if (our $CAN_HAZ_XS && $self->is_simple_get($name, $spec)) {
       $methods{$reader} = $self->_generate_xs(
         getters => $into, $reader, $name, $spec
       );
     } else {
       $self->{captures} = {};
       $methods{$reader} =
         quote_sub "${into}::${reader}"
           => '    die "'.$reader.' is a read-only accessor" if @_ > 1;'."\n"
              .$self->_generate_get($name, $spec)
           => delete $self->{captures}
         ;
     }
   }
   if (my $accessor = $spec->{accessor}) {
     _die_overwrite($into, $accessor, 'an accessor')
       if !$spec->{allow_overwrite} && defined &{"${into}::${accessor}"};
     if (
       our $CAN_HAZ_XS
       && $self->is_simple_get($name, $spec)
       && $self->is_simple_set($name, $spec)
     ) {
       $methods{$accessor} = $self->_generate_xs(
         accessors => $into, $accessor, $name, $spec
       );
     } else {
       $self->{captures} = {};
       $methods{$accessor} =
         quote_sub "${into}::${accessor}"
           => $self->_generate_getset($name, $spec)
           => delete $self->{captures}
         ;
     }
   }
   if (my $writer = $spec->{writer}) {
     _die_overwrite($into, $writer, 'a writer')
       if !$spec->{allow_overwrite} && defined &{"${into}::${writer}"};
     if (
       our $CAN_HAZ_XS
       && $self->is_simple_set($name, $spec)
     ) {
       $methods{$writer} = $self->_generate_xs(
         setters => $into, $writer, $name, $spec
       );
     } else {
       $self->{captures} = {};
       $methods{$writer} =
         quote_sub "${into}::${writer}"
           => $self->_generate_set($name, $spec)
           => delete $self->{captures}
         ;
     }
   }
   if (my $pred = $spec->{predicate}) {
     _die_overwrite($into, $pred, 'a predicate')
       if !$spec->{allow_overwrite} && defined &{"${into}::${pred}"};
     if (our $CAN_HAZ_XS && our $CAN_HAZ_XS_PRED) {
       $methods{$pred} = $self->_generate_xs(
         exists_predicates => $into, $pred, $name, $spec
       );
     } else {
       $methods{$pred} =
         quote_sub "${into}::${pred}" =>
           '    '.$self->_generate_simple_has('$_[0]', $name, $spec)."\n"
         ;
     }
   }
   if (my $pred = $spec->{builder_sub}) {
     _install_coderef( "${into}::$spec->{builder}" => $spec->{builder_sub} );
   }
   if (my $cl = $spec->{clearer}) {
     _die_overwrite($into, $cl, 'a clearer')
       if !$spec->{allow_overwrite} && defined &{"${into}::${cl}"};
     $methods{$cl} =
       quote_sub "${into}::${cl}" =>
         $self->_generate_simple_clear('$_[0]', $name, $spec)."\n"
       ;
   }
   if (my $hspec = $spec->{handles}) {
     my $asserter = $spec->{asserter} ||= '_assert_'.$name;
     my @specs = do {
       if (ref($hspec) eq 'ARRAY') {
         map [ $_ => $_ ], @$hspec;
       } elsif (ref($hspec) eq 'HASH') {
         map [ $_ => ref($hspec->{$_}) ? @{$hspec->{$_}} : $hspec->{$_} ],
           keys %$hspec;
       } elsif (!ref($hspec)) {
         map [ $_ => $_ ], use_module('Moo::Role')->methods_provided_by(use_module($hspec))
       } else {
         die "You gave me a handles of ${hspec} and I have no idea why";
       }
     };
     foreach my $delegation_spec (@specs) {
       my ($proxy, $target, @args) = @$delegation_spec;
       _die_overwrite($into, $proxy, 'a delegation')
         if !$spec->{allow_overwrite} && defined &{"${into}::${proxy}"};
       $self->{captures} = {};
       $methods{$proxy} =
         quote_sub "${into}::${proxy}" =>
           $self->_generate_delegation($asserter, $target, \@args),
           delete $self->{captures}
         ;
     }
   }
   if (my $asserter = $spec->{asserter}) {
     $self->{captures} = {};
 
 
     $methods{$asserter} =
       quote_sub "${into}::${asserter}" =>
         $self->_generate_asserter($name, $spec),
         delete $self->{captures};
   }
   \%methods;
 }
 
 sub is_simple_attribute {
   my ($self, $name, $spec) = @_;
   !grep $spec->{$_},
     qw(lazy default builder coerce isa trigger predicate weak_ref);
 }
 
 sub is_simple_get {
   my ($self, $name, $spec) = @_;
   !($spec->{lazy} and (exists $spec->{default} or $spec->{builder}));
 }
 
 sub is_simple_set {
   my ($self, $name, $spec) = @_;
   !grep $spec->{$_}, qw(coerce isa trigger weak_ref);
 }
 
 sub has_default {
   my ($self, $name, $spec) = @_;
   $spec->{builder} or exists $spec->{default} or (($spec->{is}||'') eq 'lazy');
 }
 
 sub has_eager_default {
   my ($self, $name, $spec) = @_;
   (!$spec->{lazy} and (exists $spec->{default} or $spec->{builder}));
 }
 
 sub _generate_get {
   my ($self, $name, $spec) = @_;
   my $simple = $self->_generate_simple_get('$_[0]', $name, $spec);
   if ($self->is_simple_get($name, $spec)) {
     $simple;
   } else {
     $self->_generate_use_default(
       '$_[0]', $name, $spec,
       $self->_generate_simple_has('$_[0]', $name, $spec),
     );
   }
 }
 
 sub generate_simple_has {
   my $self = shift;
   $self->{captures} = {};
   my $code = $self->_generate_simple_has(@_);
   ($code, delete $self->{captures});
 }
 
 sub _generate_simple_has {
   my ($self, $me, $name) = @_;
   "exists ${me}->{${\quotify $name}}";
 }
 
 sub _generate_simple_clear {
   my ($self, $me, $name) = @_;
   "    delete ${me}->{${\quotify $name}}\n"
 }
 
 sub generate_get_default {
   my $self = shift;
   $self->{captures} = {};
   my $code = $self->_generate_get_default(@_);
   ($code, delete $self->{captures});
 }
 
 sub generate_use_default {
   my $self = shift;
   $self->{captures} = {};
   my $code = $self->_generate_use_default(@_);
   ($code, delete $self->{captures});
 }
 
 sub _generate_use_default {
   my ($self, $me, $name, $spec, $test) = @_;
   my $get_value = $self->_generate_get_default($me, $name, $spec);
   if ($spec->{coerce}) {
     $get_value = $self->_generate_coerce(
       $name, $get_value,
       $spec->{coerce}
     )
   }
   $test." ? \n"
   .$self->_generate_simple_get($me, $name, $spec)."\n:"
   .($spec->{isa} ?
        "    do {\n      my \$value = ".$get_value.";\n"
       ."      ".$self->_generate_isa_check($name, '$value', $spec->{isa}).";\n"
       ."      ".$self->_generate_simple_set($me, $name, $spec, '$value')."\n"
       ."    }\n"
     : '    ('.$self->_generate_simple_set($me, $name, $spec, $get_value).")\n"
   );
 }
 
 sub _generate_get_default {
   my ($self, $me, $name, $spec) = @_;
   if (exists $spec->{default}) {
     ref $spec->{default}
       ? $self->_generate_call_code($name, 'default', $me, $spec->{default})
     : quotify $spec->{default};
   }
   else {
     "${me}->${\$spec->{builder}}"
   }
 }
 
 sub generate_simple_get {
   my ($self, @args) = @_;
   $self->{captures} = {};
   my $code = $self->_generate_simple_get(@args);
   ($code, delete $self->{captures});
 }
 
 sub _generate_simple_get {
   my ($self, $me, $name) = @_;
   my $name_str = quotify $name;
   "${me}->{${name_str}}";
 }
 
 sub _generate_set {
   my ($self, $name, $spec) = @_;
   if ($self->is_simple_set($name, $spec)) {
     $self->_generate_simple_set('$_[0]', $name, $spec, '$_[1]');
   } else {
     my ($coerce, $trigger, $isa_check) = @{$spec}{qw(coerce trigger isa)};
     my $value_store = '$_[0]';
     my $code;
     if ($coerce) {
       $value_store = '$value';
       $code = "do { my (\$self, \$value) = \@_;\n"
         ."        \$value = "
         .$self->_generate_coerce($name, $value_store, $coerce).";\n";
     }
     else {
       $code = "do { my \$self = shift;\n";
     }
     if ($isa_check) {
       $code .=
         "        ".$self->_generate_isa_check($name, $value_store, $isa_check).";\n";
     }
     my $simple = $self->_generate_simple_set('$self', $name, $spec, $value_store);
     if ($trigger) {
       my $fire = $self->_generate_trigger($name, '$self', $value_store, $trigger);
       $code .=
         "        ".$simple.";\n        ".$fire.";\n"
         ."        $value_store;\n";
     } else {
       $code .= "        ".$simple.";\n";
     }
     $code .= "      }";
     $code;
   }
 }
 
 sub generate_coerce {
   my $self = shift;
   $self->{captures} = {};
   my $code = $self->_generate_coerce(@_);
   ($code, delete $self->{captures});
 }
 
 sub _attr_desc {
   my ($name, $init_arg) = @_;
   return quotify($name) if !defined($init_arg) or $init_arg eq $name;
   return quotify($name).' (constructor argument: '.quotify($init_arg).')';
 }
 
 sub _generate_coerce {
   my ($self, $name, $value, $coerce, $init_arg) = @_;
   $self->_wrap_attr_exception(
     $name,
     "coercion",
     $init_arg,
     $self->_generate_call_code($name, 'coerce', "${value}", $coerce),
     1,
   );
 }
 
 sub generate_trigger {
   my $self = shift;
   $self->{captures} = {};
   my $code = $self->_generate_trigger(@_);
   ($code, delete $self->{captures});
 }
 
 sub _generate_trigger {
   my ($self, $name, $obj, $value, $trigger) = @_;
   $self->_generate_call_code($name, 'trigger', "${obj}, ${value}", $trigger);
 }
 
 sub generate_isa_check {
   my ($self, @args) = @_;
   $self->{captures} = {};
   my $code = $self->_generate_isa_check(@args);
   ($code, delete $self->{captures});
 }
 
 sub _wrap_attr_exception {
   my ($self, $name, $step, $arg, $code, $want_return) = @_;
   my $prefix = quotify("${step} for "._attr_desc($name, $arg).' failed: ');
   "do {\n"
   .'  local $Method::Generate::Accessor::CurrentAttribute = {'."\n"
   .'    init_arg => '.quotify($arg).",\n"
   .'    name     => '.quotify($name).",\n"
   .'    step     => '.quotify($step).",\n"
   ."  };\n"
   .($want_return ? '  my $_return;'."\n" : '')
   .'  my $_error;'."\n"
   ."  {\n"
   .'    my $_old_error = $@;'."\n"
   ."    if (!eval {\n"
   .'      $@ = $_old_error;'."\n"
   .($want_return ? '      $_return ='."\n" : '')
   .'      '.$code.";\n"
   ."      1;\n"
   ."    }) {\n"
   .'      $_error = $@;'."\n"
   .'      if (!ref $_error) {'."\n"
   .'        $_error = '.$prefix.'.$_error;'."\n"
   ."      }\n"
   ."    }\n"
   .'    $@ = $_old_error;'."\n"
   ."  }\n"
   .'  die $_error if $_error;'."\n"
   .($want_return ? '  $_return;'."\n" : '')
   ."}\n"
 }
 
 sub _generate_isa_check {
   my ($self, $name, $value, $check, $init_arg) = @_;
   $self->_wrap_attr_exception(
     $name,
     "isa check",
     $init_arg,
     $self->_generate_call_code($name, 'isa_check', $value, $check)
   );
 }
 
 sub _generate_call_code {
   my ($self, $name, $type, $values, $sub) = @_;
   $sub = \&{$sub} if blessed($sub);  
   if (my $quoted = quoted_from_sub($sub)) {
     my $local = 1;
     if ($values eq '@_' || $values eq '$_[0]') {
       $local = 0;
       $values = '@_';
     }
     my $code = $quoted->[1];
     if (my $captures = $quoted->[2]) {
       my $cap_name = qq{\$${type}_captures_for_}.$self->_sanitize_name($name);
       $self->{captures}->{$cap_name} = \$captures;
       Sub::Quote::inlinify($code, $values,
         Sub::Quote::capture_unroll($cap_name, $captures, 6), $local);
     } else {
       Sub::Quote::inlinify($code, $values, undef, $local);
     }
   } else {
     my $cap_name = qq{\$${type}_for_}.$self->_sanitize_name($name);
     $self->{captures}->{$cap_name} = \$sub;
     "${cap_name}->(${values})";
   }
 }
 
 sub _sanitize_name {
   my ($self, $name) = @_;
   $name =~ s/([_\W])/sprintf('_%x', ord($1))/ge;
   $name;
 }
 
 sub generate_populate_set {
   my $self = shift;
   $self->{captures} = {};
   my $code = $self->_generate_populate_set(@_);
   ($code, delete $self->{captures});
 }
 
 sub _generate_populate_set {
   my ($self, $me, $name, $spec, $source, $test, $init_arg) = @_;
   if ($self->has_eager_default($name, $spec)) {
     my $get_indent = ' ' x ($spec->{isa} ? 6 : 4);
     my $get_default = $self->_generate_get_default(
                         '$new', $name, $spec
                       );
     my $get_value =
       defined($spec->{init_arg})
         ? "(\n${get_indent}  ${test}\n"
             ."${get_indent}   ? ${source}\n${get_indent}   : "
             .$get_default
             ."\n${get_indent})"
         : $get_default;
     if ($spec->{coerce}) {
       $get_value = $self->_generate_coerce(
         $name, $get_value,
         $spec->{coerce}, $init_arg
       )
     }
     ($spec->{isa}
       ? "    {\n      my \$value = ".$get_value.";\n      "
         .$self->_generate_isa_check(
           $name, '$value', $spec->{isa}, $init_arg
         ).";\n"
         .'      '.$self->_generate_simple_set($me, $name, $spec, '$value').";\n"
         ."    }\n"
       : '    '.$self->_generate_simple_set($me, $name, $spec, $get_value).";\n"
     )
     .($spec->{trigger}
       ? '    '
         .$self->_generate_trigger(
           $name, $me, $self->_generate_simple_get($me, $name, $spec),
           $spec->{trigger}
         )." if ${test};\n"
       : ''
     );
   } else {
     "    if (${test}) {\n"
       .($spec->{coerce}
         ? "      $source = "
           .$self->_generate_coerce(
             $name, $source,
             $spec->{coerce}, $init_arg
           ).";\n"
         : ""
       )
       .($spec->{isa}
         ? "      "
           .$self->_generate_isa_check(
             $name, $source, $spec->{isa}, $init_arg
           ).";\n"
         : ""
       )
       ."      ".$self->_generate_simple_set($me, $name, $spec, $source).";\n"
       .($spec->{trigger}
         ? "      "
           .$self->_generate_trigger(
             $name, $me, $self->_generate_simple_get($me, $name, $spec),
             $spec->{trigger}
           ).";\n"
         : ""
       )
       ."    }\n";
   }
 }
 
 sub _generate_core_set {
   my ($self, $me, $name, $spec, $value) = @_;
   my $name_str = quotify $name;
   "${me}->{${name_str}} = ${value}";
 }
 
 sub _generate_simple_set {
   my ($self, $me, $name, $spec, $value) = @_;
   my $name_str = quotify $name;
   my $simple = $self->_generate_core_set($me, $name, $spec, $value);
 
   if ($spec->{weak_ref}) {
     require Scalar::Util;
     my $get = $self->_generate_simple_get($me, $name, $spec);
 
     my $weak_simple = "do { Scalar::Util::weaken(${simple}); no warnings 'void'; $get }";
     Moo::_Utils::lt_5_8_3() ? <<"EOC" : $weak_simple;
       eval { Scalar::Util::weaken($simple); 1 }
         ? do { no warnings 'void'; $get }
         : do {
           if( \$@ =~ /Modification of a read-only value attempted/) {
             require Carp;
             Carp::croak( sprintf (
               'Reference to readonly value in "%s" can not be weakened on Perl < 5.8.3',
               $name_str,
             ) );
           } else {
             die \$@;
           }
         }
 EOC
   } else {
     $simple;
   }
 }
 
 sub _generate_getset {
   my ($self, $name, $spec) = @_;
   q{(@_ > 1}."\n      ? ".$self->_generate_set($name, $spec)
     ."\n      : ".$self->_generate_get($name, $spec)."\n    )";
 }
 
 sub _generate_asserter {
   my ($self, $name, $spec) = @_;
 
   "do {\n"
    ."  my \$val = ".$self->_generate_get($name, $spec).";\n"
    ."  unless (".$self->_generate_simple_has('$_[0]', $name, $spec).") {\n"
    .qq!    die "Attempted to access '${name}' but it is not set";\n!
    ."  }\n"
    ."  \$val;\n"
    ."}\n";
 }
 sub _generate_delegation {
   my ($self, $asserter, $target, $args) = @_;
   my $arg_string = do {
     if (@$args) {
       $self->{captures}{'@curries'} = $args;
       '@curries, @_';
     } else {
       '@_';
     }
   };
   "shift->${asserter}->${target}(${arg_string});";
 }
 
 sub _generate_xs {
   my ($self, $type, $into, $name, $slot) = @_;
   Class::XSAccessor->import(
     class => $into,
     $type => { $name => $slot },
     replace => 1,
   );
   $into->can($name);
 }
 
 sub default_construction_string { '{}' }
 
 sub _validate_codulatable {
   my ($self, $setting, $value, $into, $appended) = @_;
   my $invalid = "Invalid $setting '" . overload::StrVal($value)
     . "' for $into not a coderef";
   $invalid .= " $appended" if $appended;
 
   unless (ref $value and (ref $value eq 'CODE' or blessed($value))) {
     die "$invalid or code-convertible object";
   }
 
   unless (eval { \&$value }) {
     die "$invalid and could not be converted to a coderef: $@";
   }
 
   1;
 }
 
 1;
### Method/Generate/BuildAll.pm ###
 package Method::Generate::BuildAll;
 
 use Moo::_strictures;
 use Moo::Object ();
 our @ISA = qw(Moo::Object);
 use Sub::Quote qw(quote_sub quotify);
 use Moo::_Utils;
 
 sub generate_method {
   my ($self, $into) = @_;
   quote_sub "${into}::BUILDALL", join '',
     $self->_handle_subbuild($into),
     qq{    my \$self = shift;\n},
     $self->buildall_body_for($into, '$self', '@_'),
     qq{    return \$self\n};
 }
 
 sub _handle_subbuild {
   my ($self, $into) = @_;
   '    if (ref($_[0]) ne '.quotify($into).') {'."\n".
   '      return shift->Moo::Object::BUILDALL(@_)'.";\n".
   '    }'."\n";
 }
 
 sub buildall_body_for {
   my ($self, $into, $me, $args) = @_;
   my @builds =
     grep *{_getglob($_)}{CODE},
     map "${_}::BUILD",
     reverse @{mro::get_linear_isa($into)};
   '    unless (('.$args.')[0]->{__no_BUILD__}) {'."\n"
   .join('', map qq{      ${me}->${_}(${args});\n}, @builds)
   ."   }\n";
 }
 
 1;
### Method/Generate/Constructor.pm ###
 package Method::Generate::Constructor;
 
 use Moo::_strictures;
 use Sub::Quote qw(quote_sub unquote_sub quotify);
 use Sub::Defer;
 use Moo::_Utils qw(_getstash _getglob);
 use Moo;
 
 sub register_attribute_specs {
   my ($self, @new_specs) = @_;
   $self->assert_constructor;
   my $specs = $self->{attribute_specs}||={};
   while (my ($name, $new_spec) = splice @new_specs, 0, 2) {
     if ($name =~ s/^\+//) {
       die "has '+${name}' given but no ${name} attribute already exists"
         unless my $old_spec = $specs->{$name};
       foreach my $key (keys %$old_spec) {
         if (!exists $new_spec->{$key}) {
           $new_spec->{$key} = $old_spec->{$key}
             unless $key eq 'handles';
         }
         elsif ($key eq 'moosify') {
           $new_spec->{$key} = [
             map { ref $_ eq 'ARRAY' ? @$_ : $_ }
               ($old_spec->{$key}, $new_spec->{$key})
           ];
         }
       }
     }
     if ($new_spec->{required}
       && !(
         $self->accessor_generator->has_default($name, $new_spec)
         || !exists $new_spec->{init_arg}
         || defined $new_spec->{init_arg}
       )
     ) {
       die "You cannot have a required attribute (${name})"
         . " without a default, builder, or an init_arg";
     }
     $new_spec->{index} = scalar keys %$specs
       unless defined $new_spec->{index};
     $specs->{$name} = $new_spec;
   }
   $self;
 }
 
 sub all_attribute_specs {
   $_[0]->{attribute_specs}
 }
 
 sub accessor_generator {
   $_[0]->{accessor_generator}
 }
 
 sub construction_string {
   my ($self) = @_;
   $self->{construction_string}
     ||= $self->_build_construction_string;
 }
 
 sub buildall_generator {
   require Method::Generate::BuildAll;
   Method::Generate::BuildAll->new;
 }
 
 sub _build_construction_string {
   my ($self) = @_;
   my $builder = $self->{construction_builder};
   $builder ? $self->$builder
     : 'bless('
     .$self->accessor_generator->default_construction_string
     .', $class);'
 }
 
 sub install_delayed {
   my ($self) = @_;
   $self->assert_constructor;
   my $package = $self->{package};
   my (undef, @isa) = @{mro::get_linear_isa($package)};
   my $isa = join ',', @isa;
   $self->{deferred_constructor} = defer_sub "${package}::new" => sub {
     my (undef, @new_isa) = @{mro::get_linear_isa($package)};
     if (join(',', @new_isa) ne $isa) {
       my ($expected_new) = grep { *{_getglob($_.'::new')}{CODE} } @isa;
       my ($found_new) = grep { *{_getglob($_.'::new')}{CODE} } @new_isa;
       if (($found_new||'') ne ($expected_new||'')) {
         $found_new ||= 'none';
         $expected_new ||= 'none';
         die "Expected parent constructor of $package expected to be"
         . " $expected_new, but found $found_new: changing the inheritance"
         . " chain (\@ISA) at runtime is unsupported";
       }
     }
     unquote_sub $self->generate_method(
       $package, 'new', $self->{attribute_specs}, { no_install => 1 }
     )
   };
   $self;
 }
 
 sub current_constructor {
   my ($self, $package) = @_;
   return *{_getglob("${package}::new")}{CODE};
 }
 
 sub assert_constructor {
   my ($self) = @_;
   my $package = $self->{package} or return 1;
   my $current = $self->current_constructor($package)
     or return 1;
   my $deferred = $self->{deferred_constructor}
     or die "Unknown constructor for $package already exists";
   return 1
     if $deferred == $current;
   my $current_deferred = (Sub::Defer::defer_info($current)||[])->[3];
   if ($current_deferred && $current_deferred == $deferred) {
     die "Constructor for $package has been inlined and cannot be updated";
   }
   die "Constructor for $package has been replaced with an unknown sub";
 }
 
 sub generate_method {
   my ($self, $into, $name, $spec, $quote_opts) = @_;
   foreach my $no_init (grep !exists($spec->{$_}{init_arg}), keys %$spec) {
     $spec->{$no_init}{init_arg} = $no_init;
   }
   local $self->{captures} = {};
   my $body = '    my $class = shift;'."\n"
             .'    $class = ref($class) if ref($class);'."\n";
   $body .= $self->_handle_subconstructor($into, $name);
   my $into_buildargs = $into->can('BUILDARGS');
   if ( $into_buildargs && $into_buildargs != \&Moo::Object::BUILDARGS ) {
       $body .= $self->_generate_args_via_buildargs;
   } else {
       $body .= $self->_generate_args;
   }
   $body .= $self->_check_required($spec);
   $body .= '    my $new = '.$self->construction_string.";\n";
   $body .= $self->_assign_new($spec);
   if ($into->can('BUILD')) {
     $body .= $self->buildall_generator->buildall_body_for(
       $into, '$new', '$args'
     );
   }
   $body .= '    return $new;'."\n";
   if ($into->can('DEMOLISH')) {
     require Method::Generate::DemolishAll;
     Method::Generate::DemolishAll->new->generate_method($into);
   }
   quote_sub
     "${into}::${name}" => $body,
     $self->{captures}, $quote_opts||{}
   ;
 }
 
 sub _handle_subconstructor {
   my ($self, $into, $name) = @_;
   if (my $gen = $self->{subconstructor_handler}) {
     '    if ($class ne '.quotify($into).') {'."\n".
     $gen.
     '    }'."\n";
   } else {
     ''
   }
 }
 
 sub _cap_call {
   my ($self, $code, $captures) = @_;
   @{$self->{captures}}{keys %$captures} = values %$captures if $captures;
   $code;
 }
 
 sub _generate_args_via_buildargs {
   my ($self) = @_;
   q{    my $args = $class->BUILDARGS(@_);}."\n"
   .q{    die "BUILDARGS did not return a hashref" unless ref($args) eq 'HASH';}
   ."\n";
 }
 
 sub _generate_args {
   my ($self) = @_;
   return <<'_EOA';
     my $args;
     if ( scalar @_ == 1 ) {
         unless ( defined $_[0] && ref $_[0] eq 'HASH' ) {
             die "Single parameters to new() must be a HASH ref"
                 ." data => ". $_[0] ."\n";
         }
         $args = { %{ $_[0] } };
     }
     elsif ( @_ % 2 ) {
         die "The new() method for $class expects a hash reference or a"
           . " key/value list. You passed an odd number of arguments\n";
     }
     else {
         $args = {@_};
     }
 _EOA
 
 }
 
 sub _assign_new {
   my ($self, $spec) = @_;
   my $ag = $self->accessor_generator;
   my %test;
   NAME: foreach my $name (sort keys %$spec) {
     my $attr_spec = $spec->{$name};
     next NAME unless defined($attr_spec->{init_arg})
                        or $ag->has_eager_default($name, $attr_spec);
     $test{$name} = $attr_spec->{init_arg};
   }
   join '', map {
     my $arg_key = quotify($test{$_});
     my $test = "exists \$args->{$arg_key}";
     my $source = "\$args->{$arg_key}";
     my $attr_spec = $spec->{$_};
     $self->_cap_call($ag->generate_populate_set(
       '$new', $_, $attr_spec, $source, $test, $test{$_},
     ));
   } sort keys %test;
 }
 
 sub _check_required {
   my ($self, $spec) = @_;
   my @required_init =
     map $spec->{$_}{init_arg},
       grep {
         my %s = %{$spec->{$_}}; 
         $s{required} and not($s{builder} or exists $s{default})
       } sort keys %$spec;
   return '' unless @required_init;
   '    if (my @missing = grep !exists $args->{$_}, '
     .join(', ', map quotify($_), @required_init).') {'."\n"
     .q{      die "Missing required arguments: ".join(', ', sort @missing);}."\n"
     ."    }\n";
 }
 
 sub new {
   my $class = shift;
   delete _getstash(__PACKAGE__)->{new};
   bless $class->BUILDARGS(@_), $class;
 }
 Moo->_constructor_maker_for(__PACKAGE__)
 ->register_attribute_specs(
   attribute_specs => {
     is => 'ro',
     reader => 'all_attribute_specs',
   },
   accessor_generator => { is => 'ro' },
   construction_string => { is => 'lazy' },
   construction_builder => { is => 'bare' },
   subconstructor_handler => { is => 'ro' },
   package => { is => 'bare' },
 );
 
 1;
### Method/Generate/DemolishAll.pm ###
 package Method::Generate::DemolishAll;
 
 use Moo::_strictures;
 use Moo::Object ();
 our @ISA = qw(Moo::Object);
 use Sub::Quote qw(quote_sub quotify);
 use Moo::_Utils;
 
 sub generate_method {
   my ($self, $into) = @_;
   quote_sub "${into}::DEMOLISHALL", join '',
     $self->_handle_subdemolish($into),
     qq{    my \$self = shift;\n},
     $self->demolishall_body_for($into, '$self', '@_'),
     qq{    return \$self\n};
   quote_sub "${into}::DESTROY", join '',
     q!    my $self = shift;
     my $e = do {
       local $?;
       local $@;
       require Devel::GlobalDestruction;
       eval {
         $self->DEMOLISHALL(Devel::GlobalDestruction::in_global_destruction);
       };
       $@;
     };
 
     # fatal warnings+die in DESTROY = bad times (perl rt#123398)
     no warnings FATAL => 'all';
     use warnings 'all';
     die $e if $e; # rethrow
   !;
 }
 
 sub demolishall_body_for {
   my ($self, $into, $me, $args) = @_;
   my @demolishers =
     grep *{_getglob($_)}{CODE},
     map "${_}::DEMOLISH",
     @{mro::get_linear_isa($into)};
   join '', map qq{    ${me}->${_}(${args});\n}, @demolishers;
 }
 
 sub _handle_subdemolish {
   my ($self, $into) = @_;
   '    if (ref($_[0]) ne '.quotify($into).') {'."\n".
   '      return shift->Moo::Object::DEMOLISHALL(@_)'.";\n".
   '    }'."\n";
 }
 
 1;
### Method/Inliner.pm ###
 package Method::Inliner;
 
 use Moo::_strictures;
 use Text::Balanced qw(extract_bracketed);
 use Sub::Quote ();
 
 sub slurp { do { local (@ARGV, $/) = $_[0]; <> } }
 sub splat {
   open my $out, '>', $_[1] or die "can't open $_[1]: $!";
   print $out $_[0] or die "couldn't write to $_[1]: $!";
 }
 
 sub inlinify {
   my $file = $_[0];
   my @chunks = split /(^sub.*?^}$)/sm, slurp $file;
   warn join "\n--\n", @chunks;
   my %code;
   foreach my $chunk (@chunks) {
     if (my ($name, $body) =
       $chunk =~ /^sub (\S+) {\n(.*)\n}$/s
     ) {
       $code{$name} = $body;
     }
   }
   foreach my $chunk (@chunks) {
     my ($me) = $chunk =~ /^sub.*{\n  my \((\$\w+).*\) = \@_;\n/ or next;
     my $meq = quotemeta $me;
     my $copy = $chunk;
     my ($fixed, $rest);
     while ($copy =~ s/^(.*?)${meq}->(\S+)(?=\()//s) {
       my ($front, $name) = ($1, $2);
       ((my $body), $rest) = extract_bracketed($copy, '()');
       warn "spotted ${name} - ${body}";
       if ($code{$name}) {
       warn "replacing";
         s/^\(//, s/\)$// for $body;
         $body = "${me}, ".$body;
         $fixed .= $front.Sub::Quote::inlinify($code{$name}, $body);
       } else {
         $fixed .= $front.$me.'->'.$name.$body;
       }
       $copy = $rest;
     }
     $fixed .= $rest if $fixed;
     warn $fixed if $fixed;
     $chunk = $fixed if $fixed;
   }
   print join '', @chunks;
 }
 
 1;
### Mo.pm ###
 package Mo;
 $VERSION=0.39;
 no warnings;my$M=__PACKAGE__.'::';*{$M.Object::new}=sub{my$c=shift;my$s=bless{@_},$c;my%n=%{$c.::.':E'};map{$s->{$_}=$n{$_}->()if!exists$s->{$_}}keys%n;$s};*{$M.import}=sub{import warnings;$^H|=1538;my($P,%e,%o)=caller.'::';shift;eval"no Mo::$_",&{$M.$_.::e}($P,\%e,\%o,\@_)for@_;return if$e{M};%e=(extends,sub{eval"no $_[0]()";@{$P.ISA}=$_[0]},has,sub{my$n=shift;my$m=sub{$#_?$_[0]{$n}=$_[1]:$_[0]{$n}};@_=(default,@_)if!($#_%2);$m=$o{$_}->($m,$n,@_)for sort keys%o;*{$P.$n}=$m},%e,);*{$P.$_}=$e{$_}for keys%e;@{$P.ISA}=$M.Object};
### Mo/Golf.pm ###
 
 use strict;
 use warnings;
 package Mo::Golf;
 
 our $VERSION=0.39;
 
 use PPI;
 
 my %short_names = (
     (
         map {($_, substr($_, 0, 1))}
         qw(
             args builder class default exports features
             generator import is_lazy method MoPKG name
             nonlazy_defaults options reftype self
         )
     ),
     build_subs => 'B',
     old_constructor => 'C',
     caller_pkg => 'P',
 );
 
 my %short_barewords = ( EAGERINIT => q{':E'}, NONLAZY => q{':N'} );
 
 my %hands_off = map {($_,1)} qw'&import *import';
 
 sub import {
     return unless @_ == 2 and $_[1] eq 'golf';
     binmode STDOUT;
     my $text = do { local $/; <> };
     print STDOUT golf( $text );
 };
 
 sub golf {
     my ( $text ) = @_;
 
     my $tree = PPI::Document->new( \$text );
 
     my %finder_subs = _finder_subs();
 
     my @order = qw( comments duplicate_whitespace whitespace trailing_whitespace );
 
     for my $name ( @order ) {
         my $elements = $tree->find( $finder_subs{$name} );
         die $@ if !defined $elements;
         $_->delete for @{ $elements || [] };
     }
 
     $tree->find( $finder_subs{$_} )
       for qw( del_superfluous_concat del_last_semicolon_in_block separate_version shorten_var_names shorten_barewords );
     die $@ if $@;
 
     for my $name ( 'double_semicolon' ) {
         my $elements = $tree->find( $finder_subs{$name} );
         die $@ if !defined $elements;
         $_->delete for @{ $elements || [] };
     }
 
     return $tree->serialize . "\n";
 }
 
 sub tok { "PPI::Token::$_[0]" }
 
 sub _finder_subs {
     return (
         comments => sub { $_[1]->isa( tok 'Comment' ) },
 
         duplicate_whitespace => sub {
             my ( $top, $current ) = @_;
             return 0 if !$current->isa( tok 'Whitespace' );
 
             $current->set_content(' ') if 1 < length $current->content;
 
             return 0 if !$current->next_token;
             return 0 if !$current->next_token->isa( tok 'Whitespace' );
             return 1;
         },
 
         whitespace => sub {
             my ( $top, $current ) = @_;
             return 0 if !$current->isa( tok 'Whitespace' );
             my $prev = $current->previous_token;
             my $next = $current->next_token;
 
             return 1 if $prev->isa( tok 'Number' ) and $next->isa( tok 'Operator' ) and $next->content =~ /^\W/; 
             return 1 if $prev->isa( tok 'Word' )   and $next->isa( tok 'Operator' ) and $next->content =~ /^\W/; 
             return 1 if $prev->isa( tok 'Symbol' ) and $next->isa( tok 'Operator' ) and $next->content =~ /^\W/; 
 
             return 1 if $prev->isa( tok 'Operator' ) and $next->isa( tok 'Quote::Single' ) and $next->content =~ /^\W/; 
             return 1 if $prev->isa( tok 'Operator' ) and $next->isa( tok 'Quote::Double' ) and $next->content =~ /^\W/; 
             return 1 if $prev->isa( tok 'Operator' ) and $next->isa( tok 'Symbol' )        and $next->content =~ /^\W/; 
             return 1 if $prev->isa( tok 'Operator' ) and $next->isa( tok 'Structure' )     and $next->content =~ /^\W/; 
 
             return 1 if $prev->isa( tok 'Word' )       and $next->isa( tok 'Symbol' );           
             return 1 if $prev->isa( tok 'Word' )       and $next->isa( tok 'Structure' );        
             return 1 if $prev->isa( tok 'Word' )       and $next->isa( tok 'Quote::Double' );    
             return 1 if $prev->isa( tok 'Symbol' )     and $next->isa( tok 'Structure' );        
             return 1 if $prev->isa( tok 'ArrayIndex' ) and $next->isa( tok 'Operator' );         
             return 1 if $prev->isa( tok 'Word' )       and $next->isa( tok 'Cast' );             
             return 0;
         },
 
         trailing_whitespace => sub {
             my ( $top, $current ) = @_;
             return 0 if !$current->isa( tok 'Whitespace' );
             my $prev = $current->previous_token;
 
             return 1 if $prev->isa( tok 'Structure' );                                           
             return 1 if $prev->isa( tok 'Operator' ) and $prev->content =~ /\W$/;                
             return 1 if $prev->isa( tok 'Quote::Double' );                                       
             return 1 if $prev->isa( tok 'Quote::Single' );                                       
 
             return 0;
         },
 
         double_semicolon => sub {
             my ( $top, $current ) = @_;
             return 0 if !$current->isa( tok 'Structure' );
             return 0 if $current->content ne ';';
 
             my $prev = $current->previous_token;
 
             return 0 if !$prev->isa( tok 'Structure' );
             return 0 if $prev->content ne ';';
 
             return 1;
         },
 
         del_last_semicolon_in_block => sub {
             my ( $top, $current ) = @_;
             return 0 if !$current->isa( 'PPI::Structure::Block' );
 
             my $last = $current->last_token;
 
             return 0 if !$last->isa( tok 'Structure' );
             return 0 if $last->content ne '}';
 
             my $maybe_semi = $last->previous_token;
 
             return 0 if !$maybe_semi->isa( tok 'Structure' );
             return 0 if $maybe_semi->content ne ';';
 
             $maybe_semi->delete;
 
             return 1;
         },
 
         del_superfluous_concat => sub {
             my ( $top, $current ) = @_;
             return 0 if !$current->isa( tok 'Operator' );
 
             my $prev = $current->previous_token;
             my $next = $current->next_token;
 
             return 0 if $current->content ne '.';
             return 0 if !$prev->isa( tok 'Quote::Double' );
             return 0 if !$next->isa( tok 'Quote::Double' );
 
             $current->delete;
             $prev->set_content( $prev->{separator} . $prev->string . $next->string . $prev->{separator} );
             $next->delete;
 
             return 1;
         },
 
         separate_version => sub {
             my ( $top, $current ) = @_;
             return 0 if !$current->isa( 'PPI::Statement' );
 
             my $first = $current->first_token;
             return 0 if $first->content ne '$VERSION';
 
             $current->$_( PPI::Token::Whitespace->new( "\n" ) ) for qw( insert_before insert_after );
 
             return 1;
         },
 
         shorten_var_names => sub {
             my ( $top, $current ) = @_;
             return 0 if !$current->isa( tok 'Symbol' );
 
             my $long_name = $current->canonical;
 
             return 1 if $hands_off{$long_name};
             (my $name = $long_name) =~ s/^([\$\@\%])// or die $long_name;
             my $sigil = $1;
             die "variable $long_name conflicts with shortened var name"
                 if grep {
                     $name eq $_
                 } values %short_names;
 
             my $short_name = $short_names{$name};
             $current->set_content( "$sigil$short_name" ) if $short_name;
 
             return 1;
         },
 
         shorten_barewords => sub {
             my ( $top, $current ) = @_;
             return 0 if !$current->isa( tok 'Word' );
 
             my $name = $current->content;
 
             die "bareword $name conflicts with shortened bareword"
                 if grep {
                     $name eq $_
                 } values %short_barewords;
 
             my $short_name = $short_barewords{$name};
             $current->set_content( $short_name ) if $short_name;
 
             return 1;
         },
     );
 }
 
### Mo/Inline.pm ###
 
 package Mo::Inline;
 use Mo;
 
 our $VERSION=0.39;
 
 use IO::All;
 
 my $matcher = qr/((?m:^#\s*use Mo(\s.*)?;.*\n))(?:#.*\n)*(?:.{400,}\n)?/;
 
 sub run {
     my $self = shift;
     my @files;
     if (not @_ and -d 'lib') {
         print "Searching the 'lib' directory for a Mo to inline:\n";
         @_ = 'lib';
     }
     if (not @_ or @_ == 1 and $_[0] =~ /^(?:-\?|-h|--help)$/) {
         print usage();
         return 0;
     }
     for my $name (@_) {
         die "No file or directory called '$name'"
             unless -e $name;
         die "'$name' is not a Perl module"
             if -f $name and $name !~ /\.pm$/;
         if (-f $name) {
             push @files, $name;
         }
         elsif (-d $name) {
             push @_, grep /\.pm$/, map { "$_" } io($name)->All_Files;
         }
     }
 
     die "No .pm files specified"
         unless @files;
 
     for my $file (@files) {
         my $text = io($file)->all;
         if ($text !~ $matcher) {
             print "Ignoring $file - No Mo to Inline!\n";
             next;
         }
         $self->inline($file, 1);
     }
 }
 
 sub inline {
     my ($self, $file, $noisy) = @_;
     my $text = io($file)->all;
     $text =~ s/$matcher/"$1" . &inliner($2)/eg;
     io($file)->print($text);
     print "Mo Inlined $file\n"
         if $noisy;
 }
 
 sub inliner {
     my $mo = shift;
     require Mo;
     my @features = grep {$_ ne 'qw'} ($mo =~ /(\w+)/g);
     for (@features) {
         eval "require Mo::$_; 1" or die $@;
     }
     my $inline = '';
     $inline .= $_ for map {
         my $module = $_;
         $module .= '.pm';
         my @lines = io($INC{$module})->chomp->getlines;
         $lines[-1];
     } ('Mo', map { s!::!/!g; "Mo/$_" } @features);
     return <<"...";
 #   The following line of code was produced from the previous line by
 #   Mo::Inline version $VERSION
 $inline\@f=qw[@features];use strict;use warnings;
 ...
 }
 
 sub usage {
     <<'...';
 Usage: mo-linline <perl module files or directories>
 
 ...
 }
 
 1;
 
### Mo/Moose.pm ###
 package Mo::Moose;$M="Mo::";
 $VERSION=0.39;
 *{$M.'Moose::e'}=sub{my($P,$e)=@_;$P=~s/::$//;%$e=(M=>1);require Moose;Moose->import({into=>$P});Moose::Util::MetaRole::apply_metaroles(for=>$P,class_metaroles=>{attribute=>['Attr::Trait']},)};BEGIN{package Attr::Trait;use Moose::Role;around _process_options=>sub{my$orig=shift;my$c=shift;my($n,$o)=@_;$o->{is}||='rw';$o->{lazy}||=1 if defined$o->{default}or defined$o->{builder};$c->$orig(@_)};$INC{'Attr/Trait.pm'}=1}
### Mo/Mouse.pm ###
 package Mo::Mouse;$M="Mo::";
 $VERSION=0.39;
 *{$M.'Mouse::e'}=sub{my($P,$e)=@_;$P=~s/::$//;%$e=(M=>1);require Mouse;require Mouse::Util::MetaRole;Mouse->import({into=>$P});Mouse::Util::MetaRole::apply_metaroles(for=>$P,class_metaroles=>{attribute=>['Attr::Trait']},)};BEGIN{package Attr::Trait;use Mouse::Role;around _process_options=>sub{my$orig=shift;my$c=shift;my($n,$o)=@_;$o->{is}||='rw';$o->{lazy}||=1 if defined$o->{default}or defined$o->{builder};$c->$orig(@_)};$INC{'Attr/Trait.pm'}=1}
### Mo/build.pm ###
 package Mo::build;my$M="Mo::";
 $VERSION=0.39;
 *{$M.'build::e'}=sub{my($P,$e)=@_;$e->{new}=sub{$c=shift;my$s=&{$M.Object::new}($c,@_);my@B;do{@B=($c.::BUILD,@B)}while($c)=@{$c.::ISA};exists&$_&&&$_($s)for@B;$s}};
### Mo/builder.pm ###
 package Mo::builder;my$M="Mo::";
 $VERSION=0.39;
 *{$M.'builder::e'}=sub{my($P,$e,$o)=@_;$o->{builder}=sub{my($m,$n,%a)=@_;my$b=$a{builder}or return$m;my$i=exists$a{lazy}?$a{lazy}:!${$P.':N'};$i or ${$P.':E'}{$n}=\&{$P.$b}and return$m;sub{$#_?$m->(@_):!exists$_[0]{$n}?$_[0]{$n}=$_[0]->$b:$m->(@_)}}};
### Mo/chain.pm ###
 package Mo::chain;my$M="Mo::";
 $VERSION=0.39;
 *{$M.'chain::e'}=sub{my($P,$e,$o)=@_;$o->{chain}=sub{my($m,$n,%a)=@_;$a{chain}or return$m;sub{$#_?($m->(@_),return$_[0]):$m->(@_)}}};
### Mo/coerce.pm ###
 package Mo::coerce;my$M="Mo::";
 $VERSION=0.39;
 *{$M.'coerce::e'}=sub{my($P,$e,$o)=@_;$o->{coerce}=sub{my($m,$n,%a)=@_;$a{coerce}or return$m;sub{$#_?$m->($_[0],$a{coerce}->($_[1])):$m->(@_)}};my$C=$e->{new}||*{$M.Object::new}{CODE};$e->{new}=sub{my$s=$C->(@_);$s->$_($s->{$_})for keys%$s;$s}};
### Mo/default.pm ###
 package Mo::default;my$M="Mo::";
 $VERSION=0.39;
 *{$M.'default::e'}=sub{my($P,$e,$o)=@_;$o->{default}=sub{my($m,$n,%a)=@_;exists$a{default}or return$m;my($d,$r)=$a{default};my$g='HASH'eq($r=ref$d)?sub{+{%$d}}:'ARRAY'eq$r?sub{[@$d]}:'CODE'eq$r?$d:sub{$d};my$i=exists$a{lazy}?$a{lazy}:!${$P.':N'};$i or ${$P.':E'}{$n}=$g and return$m;sub{$#_?$m->(@_):!exists$_[0]{$n}?$_[0]{$n}=$g->(@_):$m->(@_)}}};
### Mo/exporter.pm ###
 package Mo::exporter;my$M="Mo::";
 $VERSION=0.39;
 *{$M.'exporter::e'}=sub{my($P)=@_;if(@{$M.EXPORT}){*{$P.$_}=\&{$M.$_}for@{$M.EXPORT}}};
### Mo/import.pm ###
 package Mo::import;my$M="Mo::";
 $VERSION=0.39;
 my$i=\&import;*{$M.import}=sub{(@_==2 and not$_[1])?pop@_:@_==1?push@_,grep!/import/,@f:();goto&$i};
### Mo/importer.pm ###
 package Mo::importer;my$M="Mo::";
 $VERSION=0.39;
 *{$M.'importer::e'}=sub{my($P,$e,$o,$f)=@_;(my$pkg=$P)=~s/::$//;&{$P.'importer'}($pkg,@$f)if defined&{$P.'importer'}};
### Mo/is.pm ###
 package Mo::is;$M="Mo::";
 $VERSION=0.39;
 *{$M.'is::e'}=sub{my($P,$e,$o)=@_;$o->{is}=sub{my($m,$n,%a)=@_;$a{is}or return$m;sub{$#_&&$a{is}eq'ro'&&caller ne'Mo::coerce'?die$n.' is ro':$m->(@_)}}};
### Mo/nonlazy.pm ###
 package Mo::nonlazy;my$M="Mo::";
 $VERSION=0.39;
 *{$M.'nonlazy::e'}=sub{${shift().':N'}=1};
### Mo/option.pm ###
 package Mo::option;my$M="Mo::";
 $VERSION=0.39;
 *{$M.'option::e'}=sub{my($P,$e,$o)=@_;$o->{option}=sub{my($m,$n,%a)=@_;$a{option}or return$m;my$n2=$n;*{$P."read_$n2"}=sub{$_[0]->{$n2}};sub{$#_?$m->(@_):$m->(@_,1);$_[0]}}};
### Mo/required.pm ###
 package Mo::required;my$M="Mo::";
 $VERSION=0.39;
 *{$M.'required::e'}=sub{my($P,$e,$o)=@_;$o->{required}=sub{my($m,$n,%a)=@_;if($a{required}){my$C=*{$P."new"}{CODE}||*{$M.Object::new}{CODE};no warnings 'redefine';*{$P."new"}=sub{my$s=$C->(@_);my%a=@_[1..$#_];die$n." required"if!exists$a{$n};$s}}$m}};
### Mo/xs.pm ###
 package Mo::xs;my$M="Mo::";
 $VERSION=0.39;
 require Class::XSAccessor;*{$M.'xs::e'}=sub{my($P,$e,$o,$f)=@_;$P=~s/::$//;$e->{has}=sub{my($n,%a)=@_;Class::XSAccessor->import(class=>$P,accessors=>{$n=>$n})}if!grep!/^xs$/,@$f};
### Module/Implementation.pm ###
 package Module::Implementation;
 $Module::Implementation::VERSION = '0.09';
 
 use strict;
 use warnings;
 
 use Module::Runtime 0.012 qw( require_module );
 use Try::Tiny;
 
 unless ( exists $Module::Implementation::{VERSION}
     && ${ $Module::Implementation::{VERSION} } ) {
 
     $Module::Implementation::{VERSION} = \42;
 }
 
 my %Implementation;
 
 sub build_loader_sub {
     my $caller = caller();
 
     return _build_loader( $caller, @_ );
 }
 
 sub _build_loader {
     my $package = shift;
     my %args    = @_;
 
     my @implementations = @{ $args{implementations} };
     my @symbols = @{ $args{symbols} || [] };
 
     my $implementation;
     my $env_var = uc $package;
     $env_var =~ s/::/_/g;
     $env_var .= '_IMPLEMENTATION';
 
     return sub {
         my ( $implementation, $loaded ) = _load_implementation(
             $package,
             $ENV{$env_var},
             \@implementations,
         );
 
         $Implementation{$package} = $implementation;
 
         _copy_symbols( $loaded, $package, \@symbols );
 
         return $loaded;
     };
 }
 
 sub implementation_for {
     my $package = shift;
 
     return $Implementation{$package};
 }
 
 sub _load_implementation {
     my $package         = shift;
     my $env_value       = shift;
     my $implementations = shift;
 
     if ($env_value) {
         die "$env_value is not a valid implementation for $package"
             unless grep { $_ eq $env_value } @{$implementations};
 
         my $requested = "${package}::$env_value";
 
         ($requested) = $requested =~ /^(.+)$/;
 
         try {
             require_module($requested);
         }
         catch {
             require Carp;
             Carp::croak("Could not load $requested: $_");
         };
 
         return ( $env_value, $requested );
     }
     else {
         my $err;
         for my $possible ( @{$implementations} ) {
             my $try = "${package}::$possible";
 
             my $ok;
             try {
                 require_module($try);
                 $ok = 1;
             }
             catch {
                 $err .= $_ if defined $_;
             };
 
             return ( $possible, $try ) if $ok;
         }
 
         require Carp;
         if ( defined $err && length $err ) {
             Carp::croak(
                 "Could not find a suitable $package implementation: $err");
         }
         else {
             Carp::croak(
                 'Module::Runtime failed to load a module but did not throw a real error. This should never happen. Something is very broken'
             );
         }
     }
 }
 
 sub _copy_symbols {
     my $from_package = shift;
     my $to_package   = shift;
     my $symbols      = shift;
 
     for my $sym ( @{$symbols} ) {
         my $type = $sym =~ s/^([\$\@\%\&\*])// ? $1 : '&';
 
         my $from = "${from_package}::$sym";
         my $to   = "${to_package}::$sym";
 
         {
             no strict 'refs';
             no warnings 'once';
 
             *{$to}
                 = $type eq '&' ? \&{$from}
                 : $type eq '$' ? \${$from}
                 : $type eq '@' ? \@{$from}
                 : $type eq '%' ? \%{$from}
                 : $type eq '*' ? *{$from}
                 : die
                 "Can't copy symbol from $from_package to $to_package: $type$sym";
         }
     }
 }
 
 1;
 
 
 __END__
 
### Module/List.pm ###
 
 package Module::List;
 
 { use 5.006; }
 use warnings;
 use strict;
 
 use Carp qw(croak);
 use File::Spec;
 use IO::Dir 1.03;
 
 our $VERSION = "0.003";
 
 use parent "Exporter";
 our @EXPORT_OK = qw(list_modules);
 
 
 sub list_modules($$) {
 	my($prefix, $options) = @_;
 	my $trivial_syntax = $options->{trivial_syntax};
 	my($root_leaf_rx, $root_notleaf_rx);
 	my($notroot_leaf_rx, $notroot_notleaf_rx);
 	if($trivial_syntax) {
 		$root_leaf_rx = $notroot_leaf_rx = qr#:?(?:[^/:]+:)*[^/:]+:?#;
 		$root_notleaf_rx = $notroot_notleaf_rx =
 			qr#:?(?:[^/:]+:)*[^/:]+#;
 	} else {
 		$root_leaf_rx = $root_notleaf_rx = qr/[a-zA-Z_][0-9a-zA-Z_]*/;
 		$notroot_leaf_rx = $notroot_notleaf_rx = qr/[0-9a-zA-Z_]+/;
 	}
 	croak "bad module name prefix `$prefix'"
 		unless $prefix =~ /\A(?:${root_notleaf_rx}::
 					 (?:${notroot_notleaf_rx}::)*)?\z/x &&
 			 $prefix !~ /(?:\A|[^:]::)\.\.?::/;
 	my $list_modules = $options->{list_modules};
 	my $list_prefixes = $options->{list_prefixes};
 	my $list_pod = $options->{list_pod};
 	my $use_pod_dir = $options->{use_pod_dir};
 	return {} unless $list_modules || $list_prefixes || $list_pod;
 	my $recurse = $options->{recurse};
 	my @prefixes = ($prefix);
 	my %seen_prefixes;
 	my %results;
 	while(@prefixes) {
 		my $prefix = pop(@prefixes);
 		my @dir_suffix = split(/::/, $prefix);
 		my $module_rx =
 			$prefix eq "" ? $root_leaf_rx : $notroot_leaf_rx;
 		my $pm_rx = qr/\A($module_rx)\.pmc?\z/;
 		my $pod_rx = qr/\A($module_rx)\.pod\z/;
 		my $dir_rx =
 			$prefix eq "" ? $root_notleaf_rx : $notroot_notleaf_rx;
 		$dir_rx = qr/\A$dir_rx\z/;
 		foreach my $incdir (@INC) {
 			my $dir = File::Spec->catdir($incdir, @dir_suffix);
 			my $dh = IO::Dir->new($dir) or next;
 			while(defined(my $entry = $dh->read)) {
 				if(($list_modules && $entry =~ $pm_rx) ||
 						($list_pod &&
 							$entry =~ $pod_rx)) {
 					$results{$prefix.$1} = undef;
 				} elsif(($list_prefixes || $recurse) &&
 						File::Spec
 							->no_upwards($entry) &&
 						$entry =~ $dir_rx &&
 						-d File::Spec->catdir($dir,
 							$entry)) {
 					my $newpfx = $prefix.$entry."::";
 					next if exists $seen_prefixes{$newpfx};
 					$results{$newpfx} = undef
 						if $list_prefixes;
 					push @prefixes, $newpfx if $recurse;
 				}
 			}
 			next unless $list_pod && $use_pod_dir;
 			$dir = File::Spec->catdir($dir, "pod");
 			$dh = IO::Dir->new($dir) or next;
 			while(defined(my $entry = $dh->read)) {
 				if($entry =~ $pod_rx) {
 					$results{$prefix.$1} = undef;
 				}
 			}
 		}
 	}
 	return \%results;
 }
 
 
 1;
### Module/Path/More.pm ###
 package Module::Path::More;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.29'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(module_path pod_path);
 
 my $SEPARATOR;
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'Get path to locally installed Perl module',
 };
 
 BEGIN {
     if ($^O =~ /^(dos|os2)/i) {
         $SEPARATOR = '\\';
     } elsif ($^O =~ /^MacOS/i) {
         $SEPARATOR = ':';
     } else {
         $SEPARATOR = '/';
     }
 }
 
 $SPEC{module_path} = {
     v => 1.1,
     summary => 'Get path to locally installed Perl module',
     description => <<'_',
 
 Search `@INC` (reference entries are skipped) and return path(s) to Perl module
 files with the requested name.
 
 This function is like the one from `Module::Path`, except with a different
 interface and more options (finding all matches instead of the first, the option
 of not absolutizing paths, finding `.pmc` & `.pod` files, finding module
 prefixes).
 
 _
     args => {
         module => {
             summary => 'Module name to search',
             schema  => 'str*',
             req     => 1,
             pos     => 0,
         },
         find_pm => {
             summary => 'Whether to find .pm files',
             schema  => 'bool',
             default => 1,
         },
         find_pmc => {
             summary => 'Whether to find .pmc files',
             schema  => 'bool',
             default => 1,
         },
         find_pod => {
             summary => 'Whether to find .pod files',
             schema  => 'bool',
             default => 0,
         },
         find_prefix => {
             summary => 'Whether to find module prefixes',
             schema  => 'bool',
             default => 0,
         },
         all => {
             summary => 'Return all results instead of just the first',
             schema  => 'bool',
             default => 0,
         },
         abs => {
             summary => 'Whether to return absolute paths',
             schema  => 'bool',
             default => 0,
         },
     },
     result => {
         schema => ['any' => of => ['str*', ['array*' => of => 'str*']]],
     },
     result_naked => 1,
 };
 sub module_path {
     my %args = @_;
 
     my $module = $args{module} or die "Please specify module";
 
     $args{abs}         //= 0;
     $args{all}         //= 0;
     $args{find_pm}     //= 1;
     $args{find_pmc}    //= 1;
     $args{find_pod}    //= 0;
     $args{find_prefix} //= 0;
 
     require Cwd if $args{abs};
 
     my @res;
     my $add = sub { push @res, $args{abs} ? Cwd::abs_path($_[0]) : $_[0] };
 
     my $relpath;
 
     ($relpath = $module) =~ s/::/$SEPARATOR/g;
     $relpath =~ s/\.(pm|pmc|pod)\z//i;
 
     foreach my $dir (@INC) {
         next if not defined($dir);
         next if ref($dir);
 
         my $prefix = $dir . $SEPARATOR . $relpath;
         if ($args{find_pmc}) {
             my $file = $prefix . ".pmc";
             if (-f $file) {
                 $add->($file);
                 last unless $args{all};
             }
         }
         if ($args{find_pm}) {
             my $file = $prefix . ".pm";
             if (-f $file) {
                 $add->($file);
                 last unless $args{all};
             }
         }
         if ($args{find_pod}) {
             my $file = $prefix . ".pod";
             if (-f $file) {
                 $add->($file);
                 last unless $args{all};
             }
         }
         if ($args{find_prefix}) {
             if (-d $prefix) {
                 $add->($prefix);
                 last unless $args{all};
             }
         }
     }
 
     if ($args{all}) {
         return \@res;
     } else {
         return @res ? $res[0] : undef;
     }
 }
 
 $SPEC{pod_path} = {
     v => 1.1,
     summary => 'Get path to locally installed POD',
     description => <<'_',
 
 This is a shortcut for:
 
     module_path(%args, find_pm=>0, find_pmc=>0, find_pod=>1, find_prefix=>0)
 
 _
     args => {
         module => {
             summary => 'Module name to search',
             schema  => 'str*',
             req     => 1,
             pos     => 0,
         },
         all => {
             summary => 'Return all results instead of just the first',
             schema  => 'bool',
             default => 0,
         },
         abs => {
             summary => 'Whether to return absolute paths',
             schema  => 'bool',
             default => 0,
         },
     },
     result => {
         schema => ['any' => of => ['str*', ['array*' => of => 'str*']]],
     },
     result_naked => 1,
 };
 sub pod_path {
     module_path(@_, find_pm=>0, find_pmc=>0, find_pod=>1, find_prefix=>0);
 }
 
 1;
 
 __END__
 
### Module/Runtime.pm ###
 
 package Module::Runtime;
 
 BEGIN { require 5.006; }
 BEGIN { ${^WARNING_BITS} = ""; }
 
 our $VERSION = "0.014";
 
 our @EXPORT_OK = qw(
 	$module_name_rx is_module_name is_valid_module_name check_module_name
 	module_notional_filename require_module
 	use_module use_package_optimistically
 	$top_module_spec_rx $sub_module_spec_rx
 	is_module_spec is_valid_module_spec check_module_spec
 	compose_module_name
 );
 my %export_ok = map { ($_ => undef) } @EXPORT_OK;
 sub import {
 	my $me = shift;
 	my $callpkg = caller(0);
 	my $errs = "";
 	foreach(@_) {
 		if(exists $export_ok{$_}) {
 			if(/\A\$(.*)\z/s) {
 				*{$callpkg."::".$1} = \$$1;
 			} else {
 				*{$callpkg."::".$_} = \&$_;
 			}
 		} else {
 			$errs .= "\"$_\" is not exported by the $me module\n";
 		}
 	}
 	if($errs ne "") {
 		die "${errs}Can't continue after import errors ".
 			"at @{[(caller(0))[1]]} line @{[(caller(0))[2]]}.\n";
 	}
 }
 
 sub _is_string($) {
 	my($arg) = @_;
 	return defined($arg) && ref(\$arg) eq "SCALAR";
 }
 
 
 our $module_name_rx = qr/[A-Z_a-z][0-9A-Z_a-z]*(?:::[0-9A-Z_a-z]+)*/;
 
 
 my $qual_module_spec_rx =
 	qr#(?:/|::)[A-Z_a-z][0-9A-Z_a-z]*(?:(?:/|::)[0-9A-Z_a-z]+)*#;
 
 my $unqual_top_module_spec_rx =
 	qr#[A-Z_a-z][0-9A-Z_a-z]*(?:(?:/|::)[0-9A-Z_a-z]+)*#;
 
 our $top_module_spec_rx = qr/$qual_module_spec_rx|$unqual_top_module_spec_rx/o;
 
 
 my $unqual_sub_module_spec_rx = qr#[0-9A-Z_a-z]+(?:(?:/|::)[0-9A-Z_a-z]+)*#;
 
 our $sub_module_spec_rx = qr/$qual_module_spec_rx|$unqual_sub_module_spec_rx/o;
 
 
 sub is_module_name($) { _is_string($_[0]) && $_[0] =~ /\A$module_name_rx\z/o }
 
 
 *is_valid_module_name = \&is_module_name;
 
 
 sub check_module_name($) {
 	unless(&is_module_name) {
 		die +(_is_string($_[0]) ? "`$_[0]'" : "argument").
 			" is not a module name\n";
 	}
 }
 
 
 sub module_notional_filename($) {
 	&check_module_name;
 	my($name) = @_;
 	$name =~ s!::!/!g;
 	return $name.".pm";
 }
 
 
 BEGIN {
 	*_WORK_AROUND_HINT_LEAKAGE =
 		"$]" < 5.011 && !("$]" >= 5.009004 && "$]" < 5.010001)
 			? sub(){1} : sub(){0};
 	*_WORK_AROUND_BROKEN_MODULE_STATE = "$]" < 5.009 ? sub(){1} : sub(){0};
 }
 
 BEGIN { if(_WORK_AROUND_BROKEN_MODULE_STATE) { eval q{
 	sub Module::Runtime::__GUARD__::DESTROY {
 		delete $INC{$_[0]->[0]} if @{$_[0]};
 	}
 	1;
 }; die $@ if $@ ne ""; } }
 
 sub require_module($) {
 	local %^H if _WORK_AROUND_HINT_LEAKAGE;
 	if(_WORK_AROUND_BROKEN_MODULE_STATE) {
 		my $notional_filename = &module_notional_filename;
 		my $guard = bless([ $notional_filename ],
 				"Module::Runtime::__GUARD__");
 		my $result = CORE::require($notional_filename);
 		pop @$guard;
 		return $result;
 	} else {
 		return scalar(CORE::require(&module_notional_filename));
 	}
 }
 
 
 sub use_module($;$) {
 	my($name, $version) = @_;
 	require_module($name);
 	$name->VERSION($version) if @_ >= 2;
 	return $name;
 }
 
 
 sub use_package_optimistically($;$) {
 	my($name, $version) = @_;
 	my $fn = module_notional_filename($name);
 	eval { local $SIG{__DIE__}; require_module($name); };
 	die $@ if $@ ne "" &&
 		($@ !~ /\ACan't locate \Q$fn\E .+ at \Q@{[__FILE__]}\E line/s ||
 		 $@ =~ /^Compilation\ failed\ in\ require
 			 \ at\ \Q@{[__FILE__]}\E\ line/xm);
 	$name->VERSION($version) if @_ >= 2;
 	return $name;
 }
 
 
 sub is_module_spec($$) {
 	my($prefix, $spec) = @_;
 	return _is_string($spec) &&
 		$spec =~ ($prefix ? qr/\A$sub_module_spec_rx\z/o :
 				    qr/\A$top_module_spec_rx\z/o);
 }
 
 
 *is_valid_module_spec = \&is_module_spec;
 
 
 sub check_module_spec($$) {
 	unless(&is_module_spec) {
 		die +(_is_string($_[1]) ? "`$_[1]'" : "argument").
 			" is not a module specification\n";
 	}
 }
 
 
 sub compose_module_name($$) {
 	my($prefix, $spec) = @_;
 	check_module_name($prefix) if defined $prefix;
 	&check_module_spec;
 	if($spec =~ s#\A(?:/|::)##) {
 	} else {
 		$spec = $prefix."::".$spec if defined $prefix;
 	}
 	$spec =~ s#/#::#g;
 	return $spec;
 }
 
 
 1;
### Monkey/Patch/Action.pm ###
 package Monkey::Patch::Action;
 
 use 5.010;
 use warnings;
 use strict;
 
 our $VERSION = '0.04'; 
 
 use Monkey::Patch::Action::Handle;
 
 use Exporter qw(import);
 our @EXPORT_OK = qw(patch_package);
 our %EXPORT_TAGS = (all => \@EXPORT_OK);
 
 sub patch_package {
     my ($package, $subname, $action, $code, @extra) = @_;
 
     die "Please specify action" unless $action;
     if ($action eq 'delete') {
         die "code not needed for 'delete' action" if $code;
     } else {
         die "Please specify code" unless $code;
     }
 
     my $name = "$package\::$subname";
     my $type;
     if ($action eq 'add') {
         die "Adding $name: must not already exist" if defined(&$name);
         $type = 'sub';
     } elsif ($action eq 'replace') {
         die "Replacing $name: must already exist" unless defined(&$name);
         $type = 'sub';
     } elsif ($action eq 'add_or_replace') {
         $type = 'sub';
     } elsif ($action eq 'wrap') {
         die "Wrapping $name: must already exist" unless defined(&$name);
         $type = 'wrap';
     } elsif ($action eq 'delete') {
         $type = 'delete';
     } else {
         die "Unknown action '$action', please use either ".
             "wrap/add/replace/add_or_replace/delete";
     }
 
     my @caller = caller(0);
 
     Monkey::Patch::Action::Handle->new(
         package => $package,
         subname => $subname,
         extra   => \@extra,
         patcher => \@caller,
         code    => $code,
 
         -type   => $type,
     );
 }
 
 1;
 
 
 __END__
 
### Monkey/Patch/Action/Handle.pm ###
 package Monkey::Patch::Action::Handle;
 
 use 5.010;
 use strict;
 use warnings;
 
 use Scalar::Util qw(weaken);
 use Sub::Delete;
 
 our $VERSION = '0.04'; 
 
 my %stacks;
 
 sub __find_previous {
     my ($stack, $code) = @_;
     state $empty = sub {};
 
     for my $i (1..$#$stack) {
         if ($stack->[$i][1] == $code) {
             return $stack->[$i-1][2] // $stack->[$i-1][1];
         }
     }
     $empty;
 }
 
 sub new {
     my ($class, %args) = @_;
 
     my $type = $args{-type};
     delete $args{-type};
 
     my $code = $args{code};
 
     my $name = "$args{package}::$args{subname}";
     my $stack;
     if (!$stacks{$name}) {
         $stacks{$name} = [];
         push @{$stacks{$name}}, [sub => \&$name] if defined(&$name);
     }
     $stack = $stacks{$name};
 
     my $self = bless \%args, $class;
 
     no strict 'refs';
     no warnings 'redefine';
     if ($type eq 'sub') {
         push @$stack, [$type => $code];
         *$name = $code;
     } elsif ($type eq 'delete') {
         $code = sub {};
         $args{code} = $code;
         push @$stack, [$type, $code];
         delete_sub $name;
     } elsif ($type eq 'wrap') {
         weaken($self);
         my $wrapper = sub {
             my $ctx = {
                 package => $self->{package},
                 subname => $self->{subname},
                 extra   => $self->{extra},
                 orig    => __find_previous($stack, $self->{code}),
             };
             unshift @_, $ctx;
             goto &{$self->{code}};
         };
         push @$stack, [$type => $code => $wrapper];
         *$name = $wrapper;
     }
 
     $self;
 }
 
 sub DESTROY {
     my $self = shift;
 
     my $name  = "$self->{package}::$self->{subname}";
     my $stack = $stacks{$name};
     my $code  = $self->{code};
 
     for my $i (0..$#$stack) {
         if($stack->[$i][1] == $code) {
             if ($stack->[$i+1]) {
                 if ($stack->[$i+1][0] eq 'wrap' &&
                         ($i == 0 || $stack->[$i-1][0] eq 'delete')) {
                     my $p = $self->{patcher};
                     warn "Warning: unapplying patch to $name ".
                         "(applied in $p->[1]:$p->[2]) before a wrapping patch";
                 }
             }
 
             no strict 'refs';
             if ($i == @$stack-1) {
                 if ($i) {
                     no warnings 'redefine';
                     if ($stack->[$i-1][0] eq 'delete') {
                         delete_sub $name;
                     } else {
                         *$name = $stack->[$i-1][2] // $stack->[$i-1][1];
                     }
                 } else {
                     delete_sub $name;
                 }
             }
             splice @$stack, $i, 1;
             last;
         }
     }
 }
 
 1;
 
 
 __END__
 
### Moo.pm ###
 package Moo;
 
 use Moo::_strictures;
 use Moo::_Utils;
 
 our $VERSION = '2.000002';
 $VERSION = eval $VERSION;
 
 require Moo::sification;
 Moo::sification->import;
 
 our %MAKERS;
 
 sub _install_tracked {
   my ($target, $name, $code) = @_;
   $MAKERS{$target}{exports}{$name} = $code;
   _install_coderef "${target}::${name}" => "Moo::${name}" => $code;
 }
 
 sub import {
   my $target = caller;
   my $class = shift;
   _set_loaded(caller);
 
   strict->import;
   warnings->import;
 
   if ($INC{'Role/Tiny.pm'} and Role::Tiny->is_role($target)) {
     die "Cannot import Moo into a role";
   }
   $MAKERS{$target} ||= {};
   _install_tracked $target => extends => sub {
     $class->_set_superclasses($target, @_);
     $class->_maybe_reset_handlemoose($target);
     return;
   };
   _install_tracked $target => with => sub {
     require Moo::Role;
     Moo::Role->apply_roles_to_package($target, @_);
     $class->_maybe_reset_handlemoose($target);
   };
   _install_tracked $target => has => sub {
     my $name_proto = shift;
     my @name_proto = ref $name_proto eq 'ARRAY' ? @$name_proto : $name_proto;
     if (@_ % 2 != 0) {
       require Carp;
       Carp::croak("Invalid options for " . join(', ', map "'$_'", @name_proto)
         . " attribute(s): even number of arguments expected, got " . scalar @_)
     }
     my %spec = @_;
     foreach my $name (@name_proto) {
       my $spec_ref = @name_proto > 1 ? +{%spec} : \%spec;
       $class->_constructor_maker_for($target)
             ->register_attribute_specs($name, $spec_ref);
       $class->_accessor_maker_for($target)
             ->generate_method($target, $name, $spec_ref);
       $class->_maybe_reset_handlemoose($target);
     }
     return;
   };
   foreach my $type (qw(before after around)) {
     _install_tracked $target => $type => sub {
       require Class::Method::Modifiers;
       _install_modifier($target, $type, @_);
       return;
     };
   }
   return if $MAKERS{$target}{is_class}; 
   my $stash = _getstash($target);
   my @not_methods = map { *$_{CODE}||() } grep !ref($_), values %$stash;
   @{$MAKERS{$target}{not_methods}={}}{@not_methods} = @not_methods;
   $MAKERS{$target}{is_class} = 1;
   {
     no strict 'refs';
     @{"${target}::ISA"} = do {
       require Moo::Object; ('Moo::Object');
     } unless @{"${target}::ISA"};
   }
   if ($INC{'Moo/HandleMoose.pm'}) {
     Moo::HandleMoose::inject_fake_metaclass_for($target);
   }
 }
 
 sub unimport {
   my $target = caller;
   _unimport_coderefs($target, $MAKERS{$target});
 }
 
 sub _set_superclasses {
   my $class = shift;
   my $target = shift;
   foreach my $superclass (@_) {
     _load_module($superclass);
     if ($INC{'Role/Tiny.pm'} && Role::Tiny->is_role($superclass)) {
       require Carp;
       Carp::croak("Can't extend role '$superclass'");
     }
   }
   @{*{_getglob("${target}::ISA")}{ARRAY}} = @_;
   if (my $old = delete $Moo::MAKERS{$target}{constructor}) {
     $old->assert_constructor;
     delete _getstash($target)->{new};
     Moo->_constructor_maker_for($target)
        ->register_attribute_specs(%{$old->all_attribute_specs});
   }
   elsif (!$target->isa('Moo::Object')) {
     Moo->_constructor_maker_for($target);
   }
   no warnings 'once'; 
   $Moo::HandleMoose::MOUSE{$target} = [
     grep defined, map Mouse::Util::find_meta($_), @_
   ] if Mouse::Util->can('find_meta');
 }
 
 sub _maybe_reset_handlemoose {
   my ($class, $target) = @_;
   if ($INC{"Moo/HandleMoose.pm"}) {
     Moo::HandleMoose::maybe_reinject_fake_metaclass_for($target);
   }
 }
 
 sub _accessor_maker_for {
   my ($class, $target) = @_;
   return unless $MAKERS{$target};
   $MAKERS{$target}{accessor} ||= do {
     my $maker_class = do {
       if (my $m = do {
             require Sub::Defer;
             if (my $defer_target =
                   (Sub::Defer::defer_info($target->can('new'))||[])->[0]
               ) {
               my ($pkg) = ($defer_target =~ /^(.*)::[^:]+$/);
               $MAKERS{$pkg} && $MAKERS{$pkg}{accessor};
             } else {
               undef;
             }
           }) {
         ref($m);
       } else {
         require Method::Generate::Accessor;
         'Method::Generate::Accessor'
       }
     };
     $maker_class->new;
   }
 }
 
 sub _constructor_maker_for {
   my ($class, $target) = @_;
   return unless $MAKERS{$target};
   $MAKERS{$target}{constructor} ||= do {
     require Method::Generate::Constructor;
     require Sub::Defer;
 
     my %construct_opts = (
       package => $target,
       accessor_generator => $class->_accessor_maker_for($target),
       subconstructor_handler => (
         '      if ($Moo::MAKERS{$class}) {'."\n"
         .'        if ($Moo::MAKERS{$class}{constructor}) {'."\n"
         .'          return $class->'.$target.'::SUPER::new(@_);'."\n"
         .'        }'."\n"
         .'        '.$class.'->_constructor_maker_for($class);'."\n"
         .'        return $class->new(@_)'.";\n"
         .'      } elsif ($INC{"Moose.pm"} and my $meta = Class::MOP::get_metaclass_by_name($class)) {'."\n"
         .'        return $meta->new_object('."\n"
         .'          $class->can("BUILDARGS") ? $class->BUILDARGS(@_)'."\n"
         .'                      : $class->Moo::Object::BUILDARGS(@_)'."\n"
         .'        );'."\n"
         .'      }'."\n"
       ),
     );
 
     my $con;
     my @isa = @{mro::get_linear_isa($target)};
     shift @isa;
     if (my ($parent_new) = grep { *{_getglob($_.'::new')}{CODE} } @isa) {
       if ($parent_new eq 'Moo::Object') {
       }
       elsif (my $makers = $MAKERS{$parent_new}) {
         $con = $makers->{constructor};
         $construct_opts{construction_string} = $con->construction_string
           if $con;
       }
       elsif ($parent_new->can('BUILDALL')) {
         $construct_opts{construction_builder} = sub {
           my $inv = $target->can('BUILDARGS') ? '' : 'Moo::Object::';
           'do {'
           .'  my $args = $class->'.$inv.'BUILDARGS(@_);'
           .'  $args->{__no_BUILD__} = 1;'
           .'  $class->'.$target.'::SUPER::new($args);'
           .'}'
         };
       }
       else {
         $construct_opts{construction_builder} = sub {
           '$class->'.$target.'::SUPER::new('
             .($target->can('FOREIGNBUILDARGS') ?
               '$class->FOREIGNBUILDARGS(@_)' : '@_')
             .')'
         };
       }
     }
     ($con ? ref($con) : 'Method::Generate::Constructor')
       ->new(%construct_opts)
       ->install_delayed
       ->register_attribute_specs(%{$con?$con->all_attribute_specs:{}})
   }
 }
 
 sub _concrete_methods_of {
   my ($me, $role) = @_;
   my $makers = $MAKERS{$role};
   my $stash = _getstash($role);
   my $not_methods = { reverse %{$makers->{not_methods}||{}} };
   +{
     map {
       my $code = *{$stash->{$_}}{CODE};
       ( ! $code or exists $not_methods->{$code} ) ? () : ($_ => $code)
     } grep !ref($stash->{$_}), keys %$stash
   };
 }
 
 1;
 __END__
 
### Moo/HandleMoose.pm ###
 package Moo::HandleMoose;
 use Moo::_strictures;
 no warnings 'once';
 use Moo::_Utils;
 use Sub::Quote qw(quotify);
 
 our %TYPE_MAP;
 
 our $SETUP_DONE;
 
 sub import { return if $SETUP_DONE; inject_all(); $SETUP_DONE = 1; }
 
 sub inject_all {
   die "Can't inflate Moose metaclass with Moo::sification disabled"
     if $Moo::sification::disabled;
   require Class::MOP;
   inject_fake_metaclass_for($_)
     for grep $_ ne 'Moo::Object', do { no warnings 'once'; keys %Moo::MAKERS };
   inject_fake_metaclass_for($_) for keys %Moo::Role::INFO;
   require Moose::Meta::Method::Constructor;
   @Moo::HandleMoose::FakeConstructor::ISA = 'Moose::Meta::Method::Constructor';
   @Moo::HandleMoose::FakeMeta::ISA = 'Moose::Meta::Method::Meta';
 }
 
 sub maybe_reinject_fake_metaclass_for {
   my ($name) = @_;
   our %DID_INJECT;
   if (delete $DID_INJECT{$name}) {
     unless ($Moo::Role::INFO{$name}) {
       Moo->_constructor_maker_for($name)->install_delayed;
     }
     inject_fake_metaclass_for($name);
   }
 }
 
 sub inject_fake_metaclass_for {
   my ($name) = @_;
   require Class::MOP;
   require Moo::HandleMoose::FakeMetaClass;
   Class::MOP::store_metaclass_by_name(
     $name, bless({ name => $name }, 'Moo::HandleMoose::FakeMetaClass')
   );
   require Moose::Util::TypeConstraints;
   if ($Moo::Role::INFO{$name}) {
     Moose::Util::TypeConstraints::find_or_create_does_type_constraint($name);
   } else {
     Moose::Util::TypeConstraints::find_or_create_isa_type_constraint($name);
   }
 }
 
 {
   package Moo::HandleMoose::FakeConstructor;
 
   sub _uninlined_body { \&Moose::Object::new }
 }
 
 sub inject_real_metaclass_for {
   my ($name) = @_;
   our %DID_INJECT;
   return Class::MOP::get_metaclass_by_name($name) if $DID_INJECT{$name};
   require Moose; require Moo; require Moo::Role; require Scalar::Util;
   Class::MOP::remove_metaclass_by_name($name);
   my ($am_role, $am_class, $meta, $attr_specs, $attr_order) = do {
     if (my $info = $Moo::Role::INFO{$name}) {
       my @attr_info = @{$info->{attributes}||[]};
       (1, 0, Moose::Meta::Role->initialize($name),
        { @attr_info },
        [ @attr_info[grep !($_ % 2), 0..$#attr_info] ]
       )
     } elsif ( my $cmaker = Moo->_constructor_maker_for($name) ) {
       my $specs = $cmaker->all_attribute_specs;
       (0, 1, Moose::Meta::Class->initialize($name), $specs,
        [ sort { $specs->{$a}{index} <=> $specs->{$b}{index} } keys %$specs ]
       );
     } else {
        (0, 0, Moose::Meta::Class->initialize($name), {}, [] )
     }
   };
 
   foreach my $spec (values %$attr_specs) {
     if (my $inflators = delete $spec->{moosify}) {
       $_->($spec) for @$inflators;
     }
   }
 
   my %methods
     = %{($am_role ? 'Moo::Role' : 'Moo')->_concrete_methods_of($name)};
 
   if (my $info = $Moo::Role::INFO{$name}) {
     delete $info->{methods};
   }
 
   Sub::Defer::undefer_sub($_) for grep defined, values %methods;
   my @attrs;
   {
     local @{_getstash($name)}{keys %methods};
     my %seen_name;
     foreach my $name (@$attr_order) {
       $seen_name{$name} = 1;
       my %spec = %{$attr_specs->{$name}};
       my %spec_map = (
         map { $_->name => $_->init_arg||$_->name }
         (
           (grep { $_->has_init_arg }
              $meta->attribute_metaclass->meta->get_all_attributes),
           grep { exists($_->{init_arg}) ? defined($_->init_arg) : 1 }
           map {
             my $meta = Moose::Util::resolve_metatrait_alias('Attribute', $_)
                          ->meta;
             map $meta->get_attribute($_), $meta->get_attribute_list
           }  @{$spec{traits}||[]}
         )
       );
       $spec_map{traits} ||= 'traits';
 
       $spec{is} = 'ro' if $spec{is} eq 'lazy' or $spec{is} eq 'rwp';
       my $coerce = $spec{coerce};
       if (my $isa = $spec{isa}) {
         my $tc = $spec{isa} = do {
           if (my $mapped = $TYPE_MAP{$isa}) {
             my $type = $mapped->();
             unless ( Scalar::Util::blessed($type)
                 && $type->isa("Moose::Meta::TypeConstraint") ) {
               die "error inflating attribute '$name' for package '$_[0]': "
                 ."\$TYPE_MAP{$isa} did not return a valid type constraint'";
             }
             $coerce ? $type->create_child_type(name => $type->name) : $type;
           } else {
             Moose::Meta::TypeConstraint->new(
               constraint => sub { eval { &$isa; 1 } }
             );
           }
         };
         if ($coerce) {
           $tc->coercion(Moose::Meta::TypeCoercion->new)
              ->_compiled_type_coercion($coerce);
           $spec{coerce} = 1;
         }
       } elsif ($coerce) {
         my $attr = quotify($name);
         my $tc = Moose::Meta::TypeConstraint->new(
                    constraint => sub { die "This is not going to work" },
                    inlined => sub {
                       'my $r = $_[42]{'.$attr.'}; $_[42]{'.$attr.'} = 1; $r'
                    },
                  );
         $tc->coercion(Moose::Meta::TypeCoercion->new)
            ->_compiled_type_coercion($coerce);
         $spec{isa} = $tc;
         $spec{coerce} = 1;
       }
       %spec =
         map { $spec_map{$_} => $spec{$_} }
         grep { exists $spec_map{$_} }
         keys %spec;
       push @attrs, $meta->add_attribute($name => %spec);
     }
     foreach my $mouse (do { our %MOUSE; @{$MOUSE{$name}||[]} }) {
       foreach my $attr ($mouse->get_all_attributes) {
         my %spec = %{$attr};
         delete @spec{qw(
           associated_class associated_methods __METACLASS__
           provides curries
         )};
         my $name = delete $spec{name};
         next if $seen_name{$name}++;
         push @attrs, $meta->add_attribute($name => %spec);
       }
     }
   }
   foreach my $meth_name (keys %methods) {
     my $meth_code = $methods{$meth_name};
     $meta->add_method($meth_name, $meth_code) if $meth_code;
   }
 
   if ($am_role) {
     my $info = $Moo::Role::INFO{$name};
     $meta->add_required_methods(@{$info->{requires}});
     foreach my $modifier (@{$info->{modifiers}}) {
       my ($type, @args) = @$modifier;
       my $code = pop @args;
       $meta->${\"add_${type}_method_modifier"}($_, $code) for @args;
     }
   }
   elsif ($am_class) {
     foreach my $attr (@attrs) {
       foreach my $method (@{$attr->associated_methods}) {
         $method->{body} = $name->can($method->name);
       }
     }
     bless(
       $meta->find_method_by_name('new'),
       'Moo::HandleMoose::FakeConstructor',
     );
     my $meta_meth;
     if (
       $meta_meth = $meta->find_method_by_name('meta')
       and $meta_meth->body == \&Moo::Object::meta
     ) {
       bless($meta_meth, 'Moo::HandleMoose::FakeMeta');
     }
     require Method::Generate::DemolishAll;
   }
   $meta->add_role(Class::MOP::class_of($_))
     for grep !/\|/ && $_ ne $name, 
       do { no warnings 'once'; keys %{$Moo::Role::APPLIED_TO{$name}} };
   $DID_INJECT{$name} = 1;
   $meta;
 }
 
 1;
### Moo/HandleMoose/FakeMetaClass.pm ###
 package Moo::HandleMoose::FakeMetaClass;
 use Moo::_strictures;
 
 sub DESTROY { }
 
 sub AUTOLOAD {
   my ($meth) = (our $AUTOLOAD =~ /([^:]+)$/);
   my $self = shift;
   die "Can't call $meth without object instance"
     if !ref $self;
   die "Can't inflate Moose metaclass with Moo::sification disabled"
     if $Moo::sification::disabled;
   require Moo::HandleMoose;
   Moo::HandleMoose::inject_real_metaclass_for($self->{name})->$meth(@_)
 }
 sub can {
   my $self = shift;
   return $self->SUPER::can(@_)
     if !ref $self or $Moo::sification::disabled;
   require Moo::HandleMoose;
   Moo::HandleMoose::inject_real_metaclass_for($self->{name})->can(@_)
 }
 sub isa {
   my $self = shift;
   return $self->SUPER::isa(@_)
     if !ref $self or $Moo::sification::disabled;
   require Moo::HandleMoose;
   Moo::HandleMoose::inject_real_metaclass_for($self->{name})->isa(@_)
 }
 sub make_immutable { $_[0] }
 
 1;
### Moo/HandleMoose/_TypeMap.pm ###
 package Moo::HandleMoose::_TypeMap;
 use Moo::_strictures;
 
 package
   Moo::HandleMoose;
 our %TYPE_MAP;
 
 package Moo::HandleMoose::_TypeMap;
 
 use Scalar::Util ();
 use Config;
 
 our %WEAK_TYPES;
 
 sub _str_to_ref {
   my $in = shift;
   return $in
     if ref $in;
 
   if ($in =~ /(?:^|=)[A-Z]+\(0x([0-9a-zA-Z]+)\)$/) {
     my $id = do { no warnings 'portable'; hex "$1" };
     require B;
     my $sv = bless \$id, 'B::SV';
     my $ref = eval { $sv->object_2svref };
     if (!defined $ref) {
       die <<'END_ERROR';
 Moo initialization encountered types defined in a parent thread - ensure that
 Moo is require()d before any further thread spawns following a type definition.
 END_ERROR
     }
     return $ref;
   }
   return $in;
 }
 
 sub TIEHASH  { bless {}, $_[0] }
 
 sub STORE {
   my ($self, $key, $value) = @_;
   my $type = _str_to_ref($key);
   $WEAK_TYPES{$type} = $type;
   Scalar::Util::weaken($WEAK_TYPES{$type})
     if ref $type;
   $self->{$key} = $value;
 }
 
 sub FETCH    { $_[0]->{$_[1]} }
 sub FIRSTKEY { my $a = scalar keys %{$_[0]}; each %{$_[0]} }
 sub NEXTKEY  { each %{$_[0]} }
 sub EXISTS   { exists $_[0]->{$_[1]} }
 sub DELETE   { delete $_[0]->{$_[1]} }
 sub CLEAR    { %{$_[0]} = () }
 sub SCALAR   { scalar %{$_[0]} }
 
 sub CLONE {
   my @types = map {
     defined $WEAK_TYPES{$_} ? ($WEAK_TYPES{$_} => $TYPE_MAP{$_}) : ()
   } keys %TYPE_MAP;
   %WEAK_TYPES = ();
   %TYPE_MAP = @types;
 }
 
 sub DESTROY {
   my %types = %{$_[0]};
   untie %TYPE_MAP;
   %TYPE_MAP = %types;
 }
 
 if ($Config{useithreads}) {
   my @types = %TYPE_MAP;
   tie %TYPE_MAP, __PACKAGE__;
   %TYPE_MAP = @types;
 }
 
 1;
### Moo/Object.pm ###
 package Moo::Object;
 
 use Moo::_strictures;
 
 our %NO_BUILD;
 our %NO_DEMOLISH;
 our $BUILD_MAKER;
 our $DEMOLISH_MAKER;
 
 sub new {
   my $class = shift;
   unless (exists $NO_DEMOLISH{$class}) {
     unless ($NO_DEMOLISH{$class} = !$class->can('DEMOLISH')) {
       ($DEMOLISH_MAKER ||= do {
         require Method::Generate::DemolishAll;
         Method::Generate::DemolishAll->new
       })->generate_method($class);
     }
   }
   my $proto = $class->BUILDARGS(@_);
   $NO_BUILD{$class} and
     return bless({}, $class);
   $NO_BUILD{$class} = !$class->can('BUILD') unless exists $NO_BUILD{$class};
   $NO_BUILD{$class}
     ? bless({}, $class)
     : bless({}, $class)->BUILDALL($proto);
 }
 
 sub BUILDARGS {
     my $class = shift;
     if ( scalar @_ == 1 ) {
         unless ( defined $_[0] && ref $_[0] eq 'HASH' ) {
             die "Single parameters to new() must be a HASH ref"
                 ." data => ". $_[0] ."\n";
         }
         return { %{ $_[0] } };
     }
     elsif ( @_ % 2 ) {
         die "The new() method for $class expects a hash reference or a"
           . " key/value list. You passed an odd number of arguments\n";
     }
     else {
         return {@_};
     }
 }
 
 sub BUILDALL {
   my $self = shift;
   $self->${\(($BUILD_MAKER ||= do {
     require Method::Generate::BuildAll;
     Method::Generate::BuildAll->new
   })->generate_method(ref($self)))}(@_);
 }
 
 sub DEMOLISHALL {
   my $self = shift;
   $self->${\(($DEMOLISH_MAKER ||= do {
     require Method::Generate::DemolishAll;
     Method::Generate::DemolishAll->new
   })->generate_method(ref($self)))}(@_);
 }
 
 sub does {
   return !!0
     unless ($INC{'Moose/Role.pm'} || $INC{'Role/Tiny.pm'});
   require Moo::Role;
   my $does = Moo::Role->can("does_role");
   { no warnings 'redefine'; *does = $does }
   goto &$does;
 }
 
 sub meta {
   require Moo::HandleMoose::FakeMetaClass;
   my $class = ref($_[0])||$_[0];
   bless({ name => $class }, 'Moo::HandleMoose::FakeMetaClass');
 }
 
 1;
### Moo/Role.pm ###
 package Moo::Role;
 
 use Moo::_strictures;
 use Moo::_Utils;
 use Role::Tiny ();
 our @ISA = qw(Role::Tiny);
 
 our $VERSION = '2.000002';
 $VERSION = eval $VERSION;
 
 require Moo::sification;
 Moo::sification->import;
 
 BEGIN {
     *INFO = \%Role::Tiny::INFO;
     *APPLIED_TO = \%Role::Tiny::APPLIED_TO;
     *ON_ROLE_CREATE = \@Role::Tiny::ON_ROLE_CREATE;
 }
 
 our %INFO;
 our %APPLIED_TO;
 our %APPLY_DEFAULTS;
 our @ON_ROLE_CREATE;
 
 sub _install_tracked {
   my ($target, $name, $code) = @_;
   $INFO{$target}{exports}{$name} = $code;
   _install_coderef "${target}::${name}" => "Moo::Role::${name}" => $code;
 }
 
 sub import {
   my $target = caller;
   my ($me) = @_;
 
   _set_loaded(caller);
   strict->import;
   warnings->import;
   if ($Moo::MAKERS{$target} and $Moo::MAKERS{$target}{is_class}) {
     die "Cannot import Moo::Role into a Moo class";
   }
   $INFO{$target} ||= {};
   my $stash = _getstash($target);
   _install_tracked $target => has => sub {
     my $name_proto = shift;
     my @name_proto = ref $name_proto eq 'ARRAY' ? @$name_proto : $name_proto;
     if (@_ % 2 != 0) {
       require Carp;
       Carp::croak("Invalid options for " . join(', ', map "'$_'", @name_proto)
         . " attribute(s): even number of arguments expected, got " . scalar @_)
     }
     my %spec = @_;
     foreach my $name (@name_proto) {
       my $spec_ref = @name_proto > 1 ? +{%spec} : \%spec;
       ($INFO{$target}{accessor_maker} ||= do {
         require Method::Generate::Accessor;
         Method::Generate::Accessor->new
       })->generate_method($target, $name, $spec_ref);
       push @{$INFO{$target}{attributes}||=[]}, $name, $spec_ref;
       $me->_maybe_reset_handlemoose($target);
     }
   };
   foreach my $type (qw(before after around)) {
     _install_tracked $target => $type => sub {
       require Class::Method::Modifiers;
       push @{$INFO{$target}{modifiers}||=[]}, [ $type => @_ ];
       $me->_maybe_reset_handlemoose($target);
     };
   }
   _install_tracked $target => requires => sub {
     push @{$INFO{$target}{requires}||=[]}, @_;
     $me->_maybe_reset_handlemoose($target);
   };
   _install_tracked $target => with => sub {
     $me->apply_roles_to_package($target, @_);
     $me->_maybe_reset_handlemoose($target);
   };
   return if $me->is_role($target); 
   $INFO{$target}{is_role} = 1;
   *{_getglob("${target}::meta")} = $me->can('meta');
   my @not_methods = ('', map { *$_{CODE}||() } grep !ref($_), values %$stash);
   @{$INFO{$target}{not_methods}={}}{@not_methods} = @not_methods;
   $APPLIED_TO{$target} = { $target => undef };
 
   $_->($target)
     for @ON_ROLE_CREATE;
 }
 
 push @ON_ROLE_CREATE, sub {
   my $target = shift;
   if ($INC{'Moo/HandleMoose.pm'}) {
     Moo::HandleMoose::inject_fake_metaclass_for($target);
   }
 };
 
 sub meta {
   require Moo::HandleMoose::FakeMetaClass;
   my $class = ref($_[0])||$_[0];
   bless({ name => $class }, 'Moo::HandleMoose::FakeMetaClass');
 }
 
 sub unimport {
   my $target = caller;
   _unimport_coderefs($target, $INFO{$target});
 }
 
 sub _maybe_reset_handlemoose {
   my ($class, $target) = @_;
   if ($INC{"Moo/HandleMoose.pm"}) {
     Moo::HandleMoose::maybe_reinject_fake_metaclass_for($target);
   }
 }
 
 sub methods_provided_by {
   my ($self, $role) = @_;
   _load_module($role);
   $self->_inhale_if_moose($role);
   die "${role} is not a Moo::Role" unless $self->is_role($role);
   return $self->SUPER::methods_provided_by($role);
 }
 
 sub is_role {
   my ($self, $role) = @_;
   $self->_inhale_if_moose($role);
   $self->SUPER::is_role($role);
 }
 
 sub _inhale_if_moose {
   my ($self, $role) = @_;
   my $meta;
   if (!$self->SUPER::is_role($role)
       and (
         $INC{"Moose.pm"}
         and $meta = Class::MOP::class_of($role)
         and ref $meta ne 'Moo::HandleMoose::FakeMetaClass'
         and $meta->isa('Moose::Meta::Role')
       )
       or (
         Mouse::Util->can('find_meta')
         and $meta = Mouse::Util::find_meta($role)
         and $meta->isa('Mouse::Meta::Role')
      )
   ) {
     my $is_mouse = $meta->isa('Mouse::Meta::Role');
     $INFO{$role}{methods} = {
       map +($_ => $role->can($_)),
         grep $role->can($_),
         grep !($is_mouse && $_ eq 'meta'),
         grep !$meta->get_method($_)->isa('Class::MOP::Method::Meta'),
           $meta->get_method_list
     };
     $APPLIED_TO{$role} = {
       map +($_->name => 1), $meta->calculate_all_roles
     };
     $INFO{$role}{requires} = [ $meta->get_required_method_list ];
     $INFO{$role}{attributes} = [
       map +($_ => do {
         my $attr = $meta->get_attribute($_);
         my $spec = { %{ $is_mouse ? $attr : $attr->original_options } };
 
         if ($spec->{isa}) {
 
           my $get_constraint = do {
             my $pkg = $is_mouse
                         ? 'Mouse::Util::TypeConstraints'
                         : 'Moose::Util::TypeConstraints';
             _load_module($pkg);
             $pkg->can('find_or_create_isa_type_constraint');
           };
 
           my $tc = $get_constraint->($spec->{isa});
           my $check = $tc->_compiled_type_constraint;
 
           $spec->{isa} = sub {
             &$check or die "Type constraint failed for $_[0]"
           };
 
           if ($spec->{coerce}) {
 
              $spec->{coerce} = $tc->${\(
                $tc->can('coercion')||sub { $_[0] }
              )}->_compiled_type_coercion;
           }
         }
         $spec;
       }), $meta->get_attribute_list
     ];
     my $mods = $INFO{$role}{modifiers} = [];
     foreach my $type (qw(before after around)) {
       my $map = $meta->${\(
         $meta->can("get_${type}_method_modifiers_map")
         or sub { shift->{"${type}_method_modifiers"} }
       )};
       foreach my $method (keys %$map) {
         foreach my $mod (@{$map->{$method}}) {
           push @$mods, [ $type => $method => $mod ];
         }
       }
     }
     require Class::Method::Modifiers if @$mods;
     $INFO{$role}{inhaled_from_moose} = 1;
     $INFO{$role}{is_role} = 1;
   }
 }
 
 sub _maybe_make_accessors {
   my ($self, $target, $role) = @_;
   my $m;
   if ($INFO{$role} && $INFO{$role}{inhaled_from_moose}
       or $INC{"Moo.pm"}
       and $m = Moo->_accessor_maker_for($target)
       and ref($m) ne 'Method::Generate::Accessor') {
     $self->_make_accessors($target, $role);
   }
 }
 
 sub _make_accessors_if_moose {
   my ($self, $target, $role) = @_;
   if ($INFO{$role} && $INFO{$role}{inhaled_from_moose}) {
     $self->_make_accessors($target, $role);
   }
 }
 
 sub _make_accessors {
   my ($self, $target, $role) = @_;
   my $acc_gen = ($Moo::MAKERS{$target}{accessor} ||= do {
     require Method::Generate::Accessor;
     Method::Generate::Accessor->new
   });
   my $con_gen = $Moo::MAKERS{$target}{constructor};
   my @attrs = @{$INFO{$role}{attributes}||[]};
   while (my ($name, $spec) = splice @attrs, 0, 2) {
     if ($con_gen) {
       $spec = $con_gen->all_attribute_specs->{$name};
     }
     $acc_gen->generate_method($target, $name, $spec);
   }
 }
 
 sub role_application_steps {
   qw(_handle_constructor _maybe_make_accessors),
     $_[0]->SUPER::role_application_steps;
 }
 
 sub apply_roles_to_package {
   my ($me, $to, @roles) = @_;
   foreach my $role (@roles) {
     _load_module($role);
     $me->_inhale_if_moose($role);
     die "${role} is not a Moo::Role" unless $me->is_role($role);
   }
   $me->SUPER::apply_roles_to_package($to, @roles);
 }
 
 sub apply_single_role_to_package {
   my ($me, $to, $role) = @_;
   _load_module($role);
   $me->_inhale_if_moose($role);
   die "${role} is not a Moo::Role" unless $me->is_role($role);
   $me->SUPER::apply_single_role_to_package($to, $role);
 }
 
 sub create_class_with_roles {
   my ($me, $superclass, @roles) = @_;
 
   my ($new_name, $compose_name) = $me->_composite_name($superclass, @roles);
 
   return $new_name if $Role::Tiny::COMPOSED{class}{$new_name};
 
   foreach my $role (@roles) {
       _load_module($role);
       $me->_inhale_if_moose($role);
   }
 
   my $m;
   if ($INC{"Moo.pm"}
       and $m = Moo->_accessor_maker_for($superclass)
       and ref($m) ne 'Method::Generate::Accessor') {
     *{_getglob("${new_name}::ISA")} = [ $superclass ];
     $Moo::MAKERS{$new_name} = {is_class => 1};
     $me->apply_roles_to_package($new_name, @roles);
     _set_loaded($new_name, (caller)[1]);
     return $new_name;
   }
 
   $me->SUPER::create_class_with_roles($superclass, @roles);
 
   foreach my $role (@roles) {
     die "${role} is not a Moo::Role" unless $me->is_role($role);
   }
 
   $Moo::MAKERS{$new_name} = {is_class => 1};
 
   $me->_handle_constructor($new_name, $_) for @roles;
 
   _set_loaded($new_name, (caller)[1]);
   return $new_name;
 }
 
 sub apply_roles_to_object {
   my ($me, $object, @roles) = @_;
   my $new = $me->SUPER::apply_roles_to_object($object, @roles);
   _set_loaded(ref $new, (caller)[1]);
 
   my $apply_defaults = $APPLY_DEFAULTS{ref $new} ||= do {
     my %attrs = map { @{$INFO{$_}{attributes}||[]} } @roles;
 
     if ($INC{'Moo.pm'}
         and keys %attrs
         and my $con_gen = Moo->_constructor_maker_for(ref $new)
         and my $m = Moo->_accessor_maker_for(ref $new)) {
       require Sub::Quote;
 
       my $specs = $con_gen->all_attribute_specs;
 
       my $assign = "{no warnings 'void';\n";
       my %captures;
       foreach my $name ( keys %attrs ) {
         my $spec = $specs->{$name};
         if ($m->has_eager_default($name, $spec)) {
           my ($has, $has_cap)
             = $m->generate_simple_has('$_[0]', $name, $spec);
           my ($code, $pop_cap)
             = $m->generate_use_default('$_[0]', $name, $spec, $has);
 
           $assign .= $code . ";\n";
           @captures{keys %$has_cap, keys %$pop_cap}
             = (values %$has_cap, values %$pop_cap);
         }
       }
       $assign .= "}";
       Sub::Quote::quote_sub($assign, \%captures);
     }
     else {
       sub {};
     }
   };
   $new->$apply_defaults;
   return $new;
 }
 
 sub _composable_package_for {
   my ($self, $role) = @_;
   my $composed_name = 'Role::Tiny::_COMPOSABLE::'.$role;
   return $composed_name if $Role::Tiny::COMPOSED{role}{$composed_name};
   $self->_make_accessors_if_moose($composed_name, $role);
   $self->SUPER::_composable_package_for($role);
 }
 
 sub _install_single_modifier {
   my ($me, @args) = @_;
   _install_modifier(@args);
 }
 
 sub _install_does {
     my ($me, $to) = @_;
 
     my $new = $me->SUPER::_install_does($to) or return;
     return _name_coderef("${to}::DOES", $new);
 }
 
 sub does_role {
   my ($proto, $role) = @_;
   return 1
     if Role::Tiny::does_role($proto, $role);
   my $meta;
   if ($INC{'Moose.pm'}
       and $meta = Class::MOP::class_of($proto)
       and ref $meta ne 'Moo::HandleMoose::FakeMetaClass'
       and $meta->can('does_role')
   ) {
     return $meta->does_role($role);
   }
   return 0;
 }
 
 sub _handle_constructor {
   my ($me, $to, $role) = @_;
   my $attr_info = $INFO{$role} && $INFO{$role}{attributes};
   return unless $attr_info && @$attr_info;
   my $info = $INFO{$to};
   my $con = $INC{"Moo.pm"} && Moo->_constructor_maker_for($to);
   my %existing
     = $info ? @{$info->{attributes} || []}
     : $con  ? %{$con->all_attribute_specs || {}}
     : ();
 
   my @attr_info =
     map { @{$attr_info}[$_, $_+1] }
     grep { ! $existing{$attr_info->[$_]} }
     map { 2 * $_ } 0..@$attr_info/2-1;
 
   if ($info) {
     push @{$info->{attributes}||=[]}, @attr_info;
   }
   elsif ($con) {
     $con->register_attribute_specs(map ref() ? { %$_ } : $_, @attr_info);
   }
 }
 
 1;
 __END__
 
### Moo/_Utils.pm ###
 package Moo::_Utils;
 
 no warnings 'once'; 
 
 sub _getglob { \*{$_[0]} }
 sub _getstash { \%{"$_[0]::"} }
 
 use constant lt_5_8_3 => ( $] < 5.008003 or $ENV{MOO_TEST_PRE_583} ) ? 1 : 0;
 use constant can_haz_subutil => (
     $INC{"Sub/Util.pm"}
     || ( !$INC{"Sub/Name.pm"} && eval { require Sub::Util } )
   ) && defined &Sub::Util::set_subname;
 use constant can_haz_subname => (
     $INC{"Sub/Name.pm"}
     || ( !$INC{"Sub/Util.pm"} && eval { require Sub::Name } )
   ) && defined &Sub::Name::subname;
 
 use Moo::_strictures;
 use Module::Runtime qw(use_package_optimistically module_notional_filename);
 
 use Devel::GlobalDestruction ();
 use Exporter qw(import);
 use Moo::_mro;
 use Config;
 
 our @EXPORT = qw(
     _getglob _install_modifier _load_module _maybe_load_module
     _get_linear_isa _getstash _install_coderef _name_coderef
     _unimport_coderefs _in_global_destruction _set_loaded
 );
 
 sub _in_global_destruction ();
 *_in_global_destruction = \&Devel::GlobalDestruction::in_global_destruction;
 
 sub _install_modifier {
   my ($into, $type, $name, $code) = @_;
 
   if (my $to_modify = $into->can($name)) { 
     require Sub::Defer;
     Sub::Defer::undefer_sub($to_modify);
   }
 
   Class::Method::Modifiers::install_modifier(@_);
 }
 
 our %MAYBE_LOADED;
 
 sub _load_module {
   my $module = $_[0];
   my $file = module_notional_filename($module);
   use_package_optimistically($module);
   return 1
     if $INC{$file};
   my $error = $@ || "Can't locate $file";
 
   my $stash = _getstash($module)||{};
   return 1 if grep +(!ref($_) and *$_{CODE}), values %$stash;
   return 1
     if $INC{"Moose.pm"} && Class::MOP::class_of($module)
     or Mouse::Util->can('find_meta') && Mouse::Util::find_meta($module);
   die $error;
 }
 
 sub _maybe_load_module {
   my $module = $_[0];
   return $MAYBE_LOADED{$module}
     if exists $MAYBE_LOADED{$module};
   if(! eval { use_package_optimistically($module) }) {
     warn "$module exists but failed to load with error: $@";
   }
   elsif ( $INC{module_notional_filename($module)} ) {
     return $MAYBE_LOADED{$module} = 1;
   }
   return $MAYBE_LOADED{$module} = 0;
 }
 
 sub _set_loaded {
   $INC{Module::Runtime::module_notional_filename($_[0])} ||= $_[1];
 }
 
 sub _get_linear_isa {
   return mro::get_linear_isa($_[0]);
 }
 
 sub _install_coderef {
   my ($glob, $code) = (_getglob($_[0]), _name_coderef(@_));
   no warnings 'redefine';
   if (*{$glob}{CODE}) {
     *{$glob} = $code;
   }
   else {
     no warnings 'prototype';
     *{$glob} = $code;
   }
 }
 
 sub _name_coderef {
   shift if @_ > 2; 
   can_haz_subutil ? Sub::Util::set_subname(@_) :
     can_haz_subname ? Sub::Name::subname(@_) : $_[1];
 }
 
 sub _unimport_coderefs {
   my ($target, $info) = @_;
   return unless $info and my $exports = $info->{exports};
   my %rev = reverse %$exports;
   my $stash = _getstash($target);
   foreach my $name (keys %$exports) {
     if ($stash->{$name} and defined(&{$stash->{$name}})) {
       if ($rev{$target->can($name)}) {
         my $old = delete $stash->{$name};
         my $full_name = join('::',$target,$name);
         foreach my $type (qw(SCALAR HASH ARRAY IO)) {
           next unless defined(*{$old}{$type});
           no strict 'refs';
           *$full_name = *{$old}{$type};
         }
       }
     }
   }
 }
 
 if ($Config{useithreads}) {
   require Moo::HandleMoose::_TypeMap;
 }
 
 1;
### Moo/_mro.pm ###
 package Moo::_mro;
 use Moo::_strictures;
 
 if ($] >= 5.010) {
   require mro;
 } else {
   require MRO::Compat;
 }
 
 1;
### Moo/_strictures.pm ###
 package Moo::_strictures;
 use strict;
 use warnings;
 
 sub import {
   if ($ENV{MOO_FATAL_WARNINGS}) {
     require strictures;
     strictures->VERSION(2);
     @_ = ('strictures');
     goto &strictures::import;
   }
   else {
     strict->import;
     warnings->import;
   }
 }
 
 1;
### Moo/sification.pm ###
 package Moo::sification;
 
 use Moo::_strictures;
 no warnings 'once';
 use Devel::GlobalDestruction qw(in_global_destruction);
 
 sub unimport {
   die "Can't disable Moo::sification after inflation has been done"
     if $Moo::HandleMoose::SETUP_DONE;
   our $disabled = 1;
 }
 
 sub Moo::HandleMoose::AuthorityHack::DESTROY {
   unless (our $disabled or in_global_destruction) {
     require Moo::HandleMoose;
     Moo::HandleMoose->import;
   }
 }
 
 sub import {
   return
     if our $setup_done;
   if ($INC{"Moose.pm"}) {
     require Moo::HandleMoose;
     Moo::HandleMoose->import;
   } else {
     $Moose::AUTHORITY = bless({}, 'Moo::HandleMoose::AuthorityHack');
   }
   $setup_done = 1;
 }
 
 1;
### PERLANCAR/File/HomeDir.pm ###
 package PERLANCAR::File::HomeDir;
 
 our $DATE = '2015-04-08'; 
 our $VERSION = '0.02'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Exporter qw(import);
 our @EXPORT_OK = qw(
                        get_my_home_dir
                );
 
 our $DIE_ON_FAILURE = 0;
 
 sub get_my_home_dir {
     if ($^O eq 'MSWin32') {
         return $ENV{HOME} if $ENV{HOME};
         return $ENV{USERPROFILE} if $ENV{USERPROFILE};
         return join($ENV{HOMEDRIVE}, "\\", $ENV{HOMEPATH})
             if $ENV{HOMEDRIVE} && $ENV{HOMEPATH};
     } else {
         return $ENV{HOME} if $ENV{HOME};
         my @pw = getpwuid($>);
         return $pw[7] if @pw;
     }
 
     if ($DIE_ON_FAILURE) {
         die "Can't get home directory";
     } else {
         return undef;
     }
 }
 
 1;
 
 __END__
 
### Package/MoreUtil.pm ###
 package Package::MoreUtil;
 
 our $DATE = '2014-12-05'; 
 our $VERSION = '0.58'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        package_exists
                        list_package_contents
                        list_subpackages
                );
 
 sub package_exists {
     no strict 'refs';
 
     my $pkg = shift;
 
     return unless $pkg =~ /\A\w+(::\w+)*\z/;
     if ($pkg =~ s/::(\w+)\z//) {
         return !!${$pkg . "::"}{$1 . "::"};
     } else {
         return !!$::{$pkg . "::"};
     }
 }
 
 sub list_package_contents {
     no strict 'refs';
 
     my $pkg = shift;
 
     return () unless !length($pkg) || package_exists($pkg);
     my $symtbl = \%{$pkg . "::"};
 
     my %res;
     while (my ($k, $v) = each %$symtbl) {
         next if $k =~ /::$/; 
         my $n;
         if ("$v" !~ /^\*/) {
             $res{$k} = $v;
             next;
         }
         if (defined *$v{CODE}) {
             $res{$k} = *$v{CODE}; 
             $n++;
         }
         if (defined *$v{HASH}) {
             $res{"\%$k"} = \%{*$v}; 
             $n++;
         }
         if (defined *$v{ARRAY}) {
             $res{"\@$k"} = \@{*$v}; 
             $n++;
         }
         if (defined(*$v{SCALAR}) 
                 && defined(${*$v})) { 
             $res{"\$$k"} = \${*$v}; 
             $n++;
         }
 
         if (!$n) {
             $res{"\*$k"} = $v; 
         }
     }
 
     %res;
 }
 
 sub list_subpackages {
     no strict 'refs';
 
     my ($pkg, $recursive, $cur_res, $ref_mem) = @_;
 
     return () unless !length($pkg) || package_exists($pkg);
 
     $ref_mem //= {};
 
     my $symtbl = \%{$pkg . "::"};
     return () if $ref_mem->{"$symtbl"}++;
 
     my $res = $cur_res // [];
     for (sort keys %$symtbl) {
         next unless s/::$//;
         my $name = (length($pkg) ? "$pkg\::" : "" ) . $_;
         push @$res, $name;
         list_subpackages($name, 1, $res, $ref_mem) if $recursive;
     }
 
     @$res;
 }
 
 1;
 
 __END__
 
### Package/Stash.pm ###
 package Package::Stash;
 BEGIN {
   $Package::Stash::AUTHORITY = 'cpan:DOY';
 }
 $Package::Stash::VERSION = '0.37';
 use strict;
 use warnings;
 use 5.008001;
 
 our $IMPLEMENTATION;
 
 use Module::Implementation 0.06;
 
 BEGIN {
     local $ENV{PACKAGE_STASH_IMPLEMENTATION} = $IMPLEMENTATION
       if ( $IMPLEMENTATION and not $ENV{PACKAGE_STASH_IMPLEMENTATION} );
 
     Module::Implementation::build_loader_sub(
         implementations => [ 'XS', 'PP' ],
         symbols         => [qw(
             new
             name
             namespace
             add_symbol
             remove_glob
             has_symbol
             get_symbol
             get_or_add_symbol
             remove_symbol
             list_all_symbols
             get_all_symbols
         )],
     )->();
     $IMPLEMENTATION = Module::Implementation::implementation_for(__PACKAGE__);
 }
 
 
 1;
 
 __END__
 
### Package/Stash/PP.pm ###
 package Package::Stash::PP;
 BEGIN {
   $Package::Stash::PP::AUTHORITY = 'cpan:DOY';
 }
 $Package::Stash::PP::VERSION = '0.37';
 use strict;
 use warnings;
 
 use B;
 use Carp qw(confess);
 use Scalar::Util qw(blessed reftype weaken);
 use Symbol;
 use constant BROKEN_ISA_ASSIGNMENT => ($] < 5.012);
 use constant BROKEN_WEAK_STASH     => ($] < 5.010);
 use constant BROKEN_SCALAR_INITIALIZATION => ($] < 5.010);
 use constant BROKEN_GLOB_ASSIGNMENT => ($] < 5.013004);
 use constant HAS_ISA_CACHE => ($] < 5.010);
 
 
 sub new {
     my $class = shift;
     my ($package) = @_;
 
     if (!defined($package) || (ref($package) && reftype($package) ne 'HASH')) {
         confess "Package::Stash->new must be passed the name of the "
               . "package to access";
     }
     elsif (ref($package) && reftype($package) eq 'HASH') {
         confess "The PP implementation of Package::Stash does not support "
               . "anonymous stashes before perl 5.14"
             if BROKEN_GLOB_ASSIGNMENT;
 
         return bless {
             'namespace' => $package,
         }, $class;
     }
     elsif ($package =~ /\A[0-9A-Z_a-z]+(?:::[0-9A-Z_a-z]+)*\z/) {
         return bless {
             'package' => $package,
         }, $class;
     }
     else {
         confess "$package is not a module name";
     }
 
 }
 
 sub name {
     confess "Can't call name as a class method"
         unless blessed($_[0]);
     confess "Can't get the name of an anonymous package"
         unless defined($_[0]->{package});
     return $_[0]->{package};
 }
 
 sub namespace {
     confess "Can't call namespace as a class method"
         unless blessed($_[0]);
 
     if (BROKEN_WEAK_STASH) {
         no strict 'refs';
         return \%{$_[0]->name . '::'};
     }
     else {
         return $_[0]->{namespace} if defined $_[0]->{namespace};
 
         {
             no strict 'refs';
             $_[0]->{namespace} = \%{$_[0]->name . '::'};
         }
 
         weaken($_[0]->{namespace});
 
         return $_[0]->{namespace};
     }
 }
 
 {
     my %SIGIL_MAP = (
         '$' => 'SCALAR',
         '@' => 'ARRAY',
         '%' => 'HASH',
         '&' => 'CODE',
         ''  => 'IO',
     );
 
     sub _deconstruct_variable_name {
         my ($variable) = @_;
 
         my @ret;
         if (ref($variable) eq 'HASH') {
             @ret = @{$variable}{qw[name sigil type]};
         }
         else {
             (defined $variable && length $variable)
                 || confess "You must pass a variable name";
 
             my $sigil = substr($variable, 0, 1, '');
 
             if (exists $SIGIL_MAP{$sigil}) {
                 @ret = ($variable, $sigil, $SIGIL_MAP{$sigil});
             }
             else {
                 @ret = ("${sigil}${variable}", '', $SIGIL_MAP{''});
             }
         }
 
         ($ret[0] !~ /::/)
             || confess "Variable names may not contain ::";
 
         return @ret;
     }
 }
 
 sub _valid_for_type {
     my ($value, $type) = @_;
     if ($type eq 'HASH' || $type eq 'ARRAY'
      || $type eq 'IO'   || $type eq 'CODE') {
         return reftype($value) eq $type;
     }
     else {
         my $ref = reftype($value);
         return !defined($ref) || $ref eq 'SCALAR' || $ref eq 'REF' || $ref eq 'LVALUE' || $ref eq 'REGEXP' || $ref eq 'VSTRING';
     }
 }
 
 sub add_symbol {
     my ($self, $variable, $initial_value, %opts) = @_;
 
     my ($name, $sigil, $type) = _deconstruct_variable_name($variable);
 
     if (@_ > 2) {
         _valid_for_type($initial_value, $type)
             || confess "$initial_value is not of type $type";
 
         if ($^P and $^P & 0x10 && $sigil eq '&') {
             my $filename = $opts{filename};
             my $first_line_num = $opts{first_line_num};
 
             (undef, $filename, $first_line_num) = caller
                 if not defined $filename;
 
             my $last_line_num = $opts{last_line_num} || ($first_line_num ||= 0);
 
             $DB::sub{$self->name . '::' . $name} = "$filename:$first_line_num-$last_line_num";
         }
     }
 
     if (BROKEN_GLOB_ASSIGNMENT) {
         if (@_ > 2) {
             no strict 'refs';
             no warnings 'redefine';
             *{ $self->name . '::' . $name } = ref $initial_value
                 ? $initial_value : \$initial_value;
         }
         else {
             no strict 'refs';
             if (BROKEN_ISA_ASSIGNMENT && $name eq 'ISA') {
                 *{ $self->name . '::' . $name };
             }
             else {
                 my $undef = _undef_ref_for_type($type);
                 *{ $self->name . '::' . $name } = $undef;
             }
         }
     }
     else {
         my $namespace = $self->namespace;
         {
             local *__ANON__:: = $namespace;
             no strict 'refs';
             no warnings 'void';
             no warnings 'once';
             *{"__ANON__::$name"};
         }
 
         if (@_ > 2) {
             no warnings 'redefine';
             *{ $namespace->{$name} } = ref $initial_value
                 ? $initial_value : \$initial_value;
         }
         else {
             return if BROKEN_ISA_ASSIGNMENT && $name eq 'ISA';
             *{ $namespace->{$name} } = _undef_ref_for_type($type);
         }
     }
 }
 
 sub _undef_ref_for_type {
     my ($type) = @_;
 
     if ($type eq 'ARRAY') {
         return [];
     }
     elsif ($type eq 'HASH') {
         return {};
     }
     elsif ($type eq 'SCALAR') {
         return \undef;
     }
     elsif ($type eq 'IO') {
         return Symbol::geniosym;
     }
     elsif ($type eq 'CODE') {
         confess "Don't know how to vivify CODE variables";
     }
     else {
         confess "Unknown type $type in vivication";
     }
 }
 
 sub remove_glob {
     my ($self, $name) = @_;
     delete $self->namespace->{$name};
 }
 
 sub has_symbol {
     my ($self, $variable) = @_;
 
     my ($name, $sigil, $type) = _deconstruct_variable_name($variable);
 
     my $namespace = $self->namespace;
 
     return unless exists $namespace->{$name};
 
     my $entry_ref = \$namespace->{$name};
     if (reftype($entry_ref) eq 'GLOB') {
         if ($type eq 'SCALAR') {
             if (BROKEN_SCALAR_INITIALIZATION) {
                 return defined ${ *{$entry_ref}{$type} };
             }
             else {
                 my $sv = B::svref_2object($entry_ref)->SV;
                 return $sv->isa('B::SV')
                     || ($sv->isa('B::SPECIAL')
                      && $B::specialsv_name[$$sv] ne 'Nullsv');
             }
         }
         else {
             return defined *{$entry_ref}{$type};
         }
     }
     else {
         return $type eq 'CODE';
     }
 }
 
 sub get_symbol {
     my ($self, $variable, %opts) = @_;
 
     my ($name, $sigil, $type) = _deconstruct_variable_name($variable);
 
     my $namespace = $self->namespace;
 
     if (!exists $namespace->{$name}) {
         if ($opts{vivify}) {
             $self->add_symbol($variable);
         }
         else {
             return undef;
         }
     }
 
     my $entry_ref = \$namespace->{$name};
 
     if (ref($entry_ref) eq 'GLOB') {
         return *{$entry_ref}{$type};
     }
     else {
         if ($type eq 'CODE') {
             if (BROKEN_GLOB_ASSIGNMENT || defined($self->{package})) {
                 no strict 'refs';
                 return \&{ $self->name . '::' . $name };
             }
 
             if (blessed($namespace) && $namespace->isa('Package::Anon')) {
                 $namespace->bless(\(my $foo))->can($name);
             }
             else {
                 confess "Don't know how to inflate a " . ref($entry_ref)
                       . " into a full coderef (perhaps you could use"
                       . " Package::Anon instead of a bare stash?)"
             }
 
             return *{ $namespace->{$name} }{CODE};
         }
         else {
             return undef;
         }
     }
 }
 
 sub get_or_add_symbol {
     my $self = shift;
     $self->get_symbol(@_, vivify => 1);
 }
 
 sub remove_symbol {
     my ($self, $variable) = @_;
 
     my ($name, $sigil, $type) = _deconstruct_variable_name($variable);
 
 
     my %desc = (
         SCALAR => { sigil => '$', type => 'SCALAR', name => $name },
         ARRAY  => { sigil => '@', type => 'ARRAY',  name => $name },
         HASH   => { sigil => '%', type => 'HASH',   name => $name },
         CODE   => { sigil => '&', type => 'CODE',   name => $name },
         IO     => { sigil => '',  type => 'IO',     name => $name },
     );
     confess "This should never ever ever happen" if !$desc{$type};
 
     my @types_to_store = grep { $type ne $_ && $self->has_symbol($desc{$_}) }
                               keys %desc;
     my %values = map { $_, $self->get_symbol($desc{$_}) } @types_to_store;
 
     $values{SCALAR} = $self->get_symbol($desc{SCALAR})
       if !defined $values{SCALAR}
         && $type ne 'SCALAR'
         && BROKEN_SCALAR_INITIALIZATION;
 
     $self->remove_glob($name);
 
     $self->add_symbol($desc{$_} => $values{$_})
         for grep { defined $values{$_} } keys %values;
 }
 
 sub list_all_symbols {
     my ($self, $type_filter) = @_;
 
     my $namespace = $self->namespace;
     if (HAS_ISA_CACHE) {
         return grep { $_ ne '::ISA::CACHE::' } keys %{$namespace}
             unless defined $type_filter;
     }
     else {
         return keys %{$namespace}
             unless defined $type_filter;
     }
 
     if ($type_filter eq 'CODE') {
         return grep {
             ref(\$namespace->{$_}) ne 'GLOB'
                 || defined(*{$namespace->{$_}}{CODE})
         } keys %{$namespace};
     }
     elsif ($type_filter eq 'SCALAR') {
         return grep {
             !(HAS_ISA_CACHE && $_ eq '::ISA::CACHE::') &&
             (BROKEN_SCALAR_INITIALIZATION
                 ? (ref(\$namespace->{$_}) eq 'GLOB'
                       && defined(${*{$namespace->{$_}}{'SCALAR'}}))
                 : (do {
                       my $entry = \$namespace->{$_};
                       ref($entry) eq 'GLOB'
                           && B::svref_2object($entry)->SV->isa('B::SV')
                   }))
         } keys %{$namespace};
     }
     else {
         return grep {
             ref(\$namespace->{$_}) eq 'GLOB'
                 && defined(*{$namespace->{$_}}{$type_filter})
         } keys %{$namespace};
     }
 }
 
 sub get_all_symbols {
     my ($self, $type_filter) = @_;
 
     my $namespace = $self->namespace;
     return { %{$namespace} } unless defined $type_filter;
 
     return {
         map { $_ => $self->get_symbol({name => $_, type => $type_filter}) }
             $self->list_all_symbols($type_filter)
     }
 }
 
 
 1;
 
 __END__
 
### Params/Util.pm ###
 package Params::Util;
 
 
 use 5.00503;
 use strict;
 require overload;
 require Exporter;
 require Scalar::Util;
 require DynaLoader;
 
 use vars qw{$VERSION @ISA @EXPORT_OK %EXPORT_TAGS};
 
 $VERSION   = '1.07';
 @ISA       = qw{
 	Exporter
 	DynaLoader
 };
 @EXPORT_OK = qw{
 	_STRING     _IDENTIFIER
 	_CLASS      _CLASSISA   _SUBCLASS  _DRIVER  _CLASSDOES
 	_NUMBER     _POSINT     _NONNEGINT
 	_SCALAR     _SCALAR0
 	_ARRAY      _ARRAY0     _ARRAYLIKE
 	_HASH       _HASH0      _HASHLIKE
 	_CODE       _CODELIKE
 	_INVOCANT   _REGEX      _INSTANCE  _INSTANCEDOES
 	_SET        _SET0
 	_HANDLE
 };
 %EXPORT_TAGS = ( ALL => \@EXPORT_OK );
 
 eval {
 	local $ENV{PERL_DL_NONLAZY} = 0 if $ENV{PERL_DL_NONLAZY};
 	bootstrap Params::Util $VERSION;
 	1;
 } unless $ENV{PERL_PARAMS_UTIL_PP};
 
 my $SU = eval "$Scalar::Util::VERSION" || 0;
 if ( $SU >= 1.18 ) { 
 	Scalar::Util->import('looks_like_number');
 } else {
 	eval <<'END_PERL';
 sub looks_like_number {
 	local $_ = shift;
 
 	# checks from perlfaq4
 	return 0 if !defined($_);
 	if (ref($_)) {
 		return overload::Overloaded($_) ? defined(0 + $_) : 0;
 	}
 	return 1 if (/^[+-]?[0-9]+$/); # is a +/- integer
 	return 1 if (/^([+-]?)(?=[0-9]|\.[0-9])[0-9]*(\.[0-9]*)?([Ee]([+-]?[0-9]+))?$/); # a C float
 	return 1 if ($] >= 5.008 and /^(Inf(inity)?|NaN)$/i) or ($] >= 5.006001 and /^Inf$/i);
 
 	0;
 }
 END_PERL
 }
 
 
 
 
 
 
 
 eval <<'END_PERL' unless defined &_STRING;
 sub _STRING ($) {
 	(defined $_[0] and ! ref $_[0] and length($_[0])) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_IDENTIFIER;
 sub _IDENTIFIER ($) {
 	(defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*\z/s) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_CLASS;
 sub _CLASS ($) {
 	(defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_CLASSISA;
 sub _CLASSISA ($$) {
 	(defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s and $_[0]->isa($_[1])) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_CLASSDOES;
 sub _CLASSDOES ($$) {
 	(defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s and $_[0]->DOES($_[1])) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_SUBCLASS;
 sub _SUBCLASS ($$) {
 	(defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s and $_[0] ne $_[1] and $_[0]->isa($_[1])) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_NUMBER;
 sub _NUMBER ($) {
 	( defined $_[0] and ! ref $_[0] and looks_like_number($_[0]) )
 	? $_[0]
 	: undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_POSINT;
 sub _POSINT ($) {
 	(defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[1-9]\d*$/) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_NONNEGINT;
 sub _NONNEGINT ($) {
 	(defined $_[0] and ! ref $_[0] and $_[0] =~ m/^(?:0|[1-9]\d*)$/) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_SCALAR;
 sub _SCALAR ($) {
 	(ref $_[0] eq 'SCALAR' and defined ${$_[0]} and ${$_[0]} ne '') ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_SCALAR0;
 sub _SCALAR0 ($) {
 	ref $_[0] eq 'SCALAR' ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_ARRAY;
 sub _ARRAY ($) {
 	(ref $_[0] eq 'ARRAY' and @{$_[0]}) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_ARRAY0;
 sub _ARRAY0 ($) {
 	ref $_[0] eq 'ARRAY' ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_ARRAYLIKE;
 sub _ARRAYLIKE {
 	(defined $_[0] and ref $_[0] and (
 		(Scalar::Util::reftype($_[0]) eq 'ARRAY')
 		or
 		overload::Method($_[0], '@{}')
 	)) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_HASH;
 sub _HASH ($) {
 	(ref $_[0] eq 'HASH' and scalar %{$_[0]}) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_HASH0;
 sub _HASH0 ($) {
 	ref $_[0] eq 'HASH' ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_HASHLIKE;
 sub _HASHLIKE {
 	(defined $_[0] and ref $_[0] and (
 		(Scalar::Util::reftype($_[0]) eq 'HASH')
 		or
 		overload::Method($_[0], '%{}')
 	)) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_CODE;
 sub _CODE ($) {
 	ref $_[0] eq 'CODE' ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_CODELIKE;
 sub _CODELIKE($) {
 	(
 		(Scalar::Util::reftype($_[0])||'') eq 'CODE'
 		or
 		Scalar::Util::blessed($_[0]) and overload::Method($_[0],'&{}')
 	)
 	? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_INVOCANT;
 sub _INVOCANT($) {
 	(defined $_[0] and
 		(defined Scalar::Util::blessed($_[0])
 		or      
 		# We used to check for stash definedness, but any class-like name is a
 		# valid invocant for UNIVERSAL methods, so we stopped. -- rjbs, 2006-07-02
 		Params::Util::_CLASS($_[0]))
 	) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_INSTANCE;
 sub _INSTANCE ($$) {
 	(Scalar::Util::blessed($_[0]) and $_[0]->isa($_[1])) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_INSTANCEDOES;
 sub _INSTANCEDOES ($$) {
 	(Scalar::Util::blessed($_[0]) and $_[0]->DOES($_[1])) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_REGEX;
 sub _REGEX ($) {
 	(defined $_[0] and 'Regexp' eq ref($_[0])) ? $_[0] : undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_SET;
 sub _SET ($$) {
 	my $set = shift;
 	_ARRAY($set) or return undef;
 	foreach my $item ( @$set ) {
 		_INSTANCE($item,$_[0]) or return undef;
 	}
 	$set;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_SET0;
 sub _SET0 ($$) {
 	my $set = shift;
 	_ARRAY0($set) or return undef;
 	foreach my $item ( @$set ) {
 		_INSTANCE($item,$_[0]) or return undef;
 	}
 	$set;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_HANDLE;
 sub _HANDLE {
 	my $it = shift;
 
 	# It has to be defined, of course
 	unless ( defined $it ) {
 		return undef;
 	}
 
 	# Normal globs are considered to be file handles
 	if ( ref $it eq 'GLOB' ) {
 		return $it;
 	}
 
 	# Check for a normal tied filehandle
 	# Side Note: 5.5.4's tied() and can() doesn't like getting undef
 	if ( tied($it) and tied($it)->can('TIEHANDLE') ) {
 		return $it;
 	}
 
 	# There are no other non-object handles that we support
 	unless ( Scalar::Util::blessed($it) ) {
 		return undef;
 	}
 
 	# Check for a common base classes for conventional IO::Handle object
 	if ( $it->isa('IO::Handle') ) {
 		return $it;
 	}
 
 
 	# Check for tied file handles using Tie::Handle
 	if ( $it->isa('Tie::Handle') ) {
 		return $it;
 	}
 
 	# IO::Scalar is not a proper seekable, but it is valid is a
 	# regular file handle
 	if ( $it->isa('IO::Scalar') ) {
 		return $it;
 	}
 
 	# Yet another special case for IO::String, which refuses (for now
 	# anyway) to become a subclass of IO::Handle.
 	if ( $it->isa('IO::String') ) {
 		return $it;
 	}
 
 	# This is not any sort of object we know about
 	return undef;
 }
 END_PERL
 
 
 eval <<'END_PERL' unless defined &_DRIVER;
 sub _DRIVER ($$) {
 	(defined _CLASS($_[0]) and eval "require $_[0];" and ! $@ and $_[0]->isa($_[1]) and $_[0] ne $_[1]) ? $_[0] : undef;
 }
 END_PERL
 
 1;
 
### Params/Validate.pm ###
 package Params::Validate;
 
 use 5.008001;
 
 use strict;
 use warnings;
 
 our $VERSION = '1.21';
 
 use Exporter;
 use Module::Implementation;
 use Params::Validate::Constants;
 
 use vars qw( $NO_VALIDATION %OPTIONS $options );
 
 our @ISA = 'Exporter';
 
 my @types = qw(
     SCALAR
     ARRAYREF
     HASHREF
     CODEREF
     GLOB
     GLOBREF
     SCALARREF
     HANDLE
     BOOLEAN
     UNDEF
     OBJECT
 );
 
 our %EXPORT_TAGS = (
     'all' => [
         qw( validate validate_pos validation_options validate_with ),
         @types
     ],
     types => \@types,
 );
 
 our @EXPORT_OK = ( @{ $EXPORT_TAGS{all} }, 'set_options' );
 our @EXPORT = qw( validate validate_pos );
 
 $NO_VALIDATION = $ENV{PERL_NO_VALIDATION};
 
 {
     my $loader = Module::Implementation::build_loader_sub(
         implementations => [ 'XS', 'PP' ],
         symbols         => [
             qw(
                 validate
                 validate_pos
                 validate_with
                 validation_options
                 set_options
                 ),
         ],
     );
 
     $ENV{PARAMS_VALIDATE_IMPLEMENTATION} = 'PP' if $ENV{PV_TEST_PERL};
 
     $loader->();
 }
 
 1;
 
 
 __END__
 
### Params/Validate/Constants.pm ###
 package Params::Validate::Constants;
 
 use strict;
 use warnings;
 
 our $VERSION = '1.21';
 
 our @ISA = 'Exporter';
 
 our @EXPORT = qw(
     SCALAR
     ARRAYREF
     HASHREF
     CODEREF
     GLOB
     GLOBREF
     SCALARREF
     HANDLE
     BOOLEAN
     UNDEF
     OBJECT
     UNKNOWN
 );
 
 sub SCALAR ()    { 1 }
 sub ARRAYREF ()  { 2 }
 sub HASHREF ()   { 4 }
 sub CODEREF ()   { 8 }
 sub GLOB ()      { 16 }
 sub GLOBREF ()   { 32 }
 sub SCALARREF () { 64 }
 sub UNKNOWN ()   { 128 }
 sub UNDEF ()     { 256 }
 sub OBJECT ()    { 512 }
 
 sub HANDLE ()  { 16 | 32 }
 sub BOOLEAN () { 1 | 256 }
 
 1;
### Params/Validate/PP.pm ###
 package Params::Validate::PP;
 
 use strict;
 use warnings;
 
 our $VERSION = '1.21';
 
 use Params::Validate::Constants;
 use Scalar::Util 1.10 ();
 
 our $options;
 
 
 sub validate_pos (\@@) {
     return if $Params::Validate::NO_VALIDATION && !defined wantarray;
 
     my $p = shift;
 
     my @specs = @_;
 
     my @p = @$p;
     if ($Params::Validate::NO_VALIDATION) {
 
         for ( my $x = $#p + 1; $x <= $#specs; $x++ ) {
             $p[$x] = $specs[$x]->{default}
                 if ref $specs[$x] && exists $specs[$x]->{default};
         }
 
         return wantarray ? @p : \@p;
     }
 
     local $options ||= _get_options( ( caller(0) )[0] )
         unless defined $options;
 
     my $min = 0;
 
     while (1) {
         last
             unless (
             ref $specs[$min]
             ? !( exists $specs[$min]->{default} || $specs[$min]->{optional} )
             : $specs[$min]
             );
 
         $min++;
     }
 
     my $max = scalar @specs;
 
     my $actual = scalar @p;
     unless ( $actual >= $min
         && ( $options->{allow_extra} || $actual <= $max ) ) {
         my $minmax = (
             $options->{allow_extra}
             ? "at least $min"
             : ( $min != $max ? "$min - $max" : $max )
         );
 
         my $val = $options->{allow_extra} ? $min : $max;
         $minmax .= $val != 1 ? ' were' : ' was';
 
         my $called = _get_called();
 
         $options->{on_fail}->( "$actual parameter"
                 . ( $actual != 1 ? 's'    : '' ) . " "
                 . ( $actual != 1 ? 'were' : 'was' )
                 . " passed to $called but $minmax expected\n" );
     }
 
     my $bigger = $#p > $#specs ? $#p : $#specs;
     foreach ( 0 .. $bigger ) {
         my $spec = $specs[$_];
 
         next unless ref $spec;
 
         if ( $_ <= $#p ) {
             _validate_one_param(
                 $p[$_], \@p, $spec,
                 'Parameter #' . ( $_ + 1 ) . ' (%s)'
             );
         }
 
         $p[$_] = $spec->{default} if $_ > $#p && exists $spec->{default};
     }
 
     _validate_pos_depends( \@p, \@specs );
 
     foreach (
         grep {
                    defined $p[$_]
                 && !ref $p[$_]
                 && ref $specs[$_]
                 && $specs[$_]{untaint}
         } 0 .. $bigger
         ) {
         ( $p[$_] ) = $p[$_] =~ /(.+)/;
     }
 
     return wantarray ? @p : \@p;
 }
 
 sub _validate_pos_depends {
     my ( $p, $specs ) = @_;
 
     for my $p_idx ( 0 .. $#$p ) {
         my $spec = $specs->[$p_idx];
 
         next
             unless $spec
             && UNIVERSAL::isa( $spec, 'HASH' )
             && exists $spec->{depends};
 
         my $depends = $spec->{depends};
 
         if ( ref $depends ) {
             require Carp;
             local $Carp::CarpLevel = 2;
             Carp::croak(
                 "Arguments to 'depends' for validate_pos() must be a scalar");
         }
 
         my $p_size = scalar @$p;
         if ( $p_size < $depends - 1 ) {
             my $error
                 = (   "Parameter #"
                     . ( $p_idx + 1 )
                     . " depends on parameter #"
                     . $depends
                     . ", which was not given" );
 
             $options->{on_fail}->($error);
         }
     }
     return 1;
 }
 
 sub _validate_named_depends {
     my ( $p, $specs ) = @_;
 
     foreach my $pname ( keys %$p ) {
         my $spec = $specs->{$pname};
 
         next
             unless $spec
             && UNIVERSAL::isa( $spec, 'HASH' )
             && $spec->{depends};
 
         unless ( UNIVERSAL::isa( $spec->{depends}, 'ARRAY' )
             || !ref $spec->{depends} ) {
             require Carp;
             local $Carp::CarpLevel = 2;
             Carp::croak(
                 "Arguments to 'depends' must be a scalar or arrayref");
         }
 
         foreach my $depends_name (
             ref $spec->{depends}
             ? @{ $spec->{depends} }
             : $spec->{depends}
             ) {
             unless ( exists $p->{$depends_name} ) {
                 my $error
                     = (   "Parameter '$pname' depends on parameter '"
                         . $depends_name
                         . "', which was not given" );
 
                 $options->{on_fail}->($error);
             }
         }
     }
 }
 
 sub validate (\@$) {
     return if $Params::Validate::NO_VALIDATION && !defined wantarray;
 
     my $p = $_[0];
 
     my $specs = $_[1];
     local $options = _get_options( ( caller(0) )[0] ) unless defined $options;
 
     if ( ref $p eq 'ARRAY' ) {
 
         if ( ref $p->[0] ) {
             $p = { %{ $p->[0] } };
         }
         elsif ( @$p % 2 ) {
             my $called = _get_called();
 
             $options->{on_fail}
                 ->(   "Odd number of parameters in call to $called "
                     . "when named parameters were expected\n" );
         }
         else {
             $p = {@$p};
         }
     }
 
     if ( $options->{normalize_keys} ) {
         $specs = _normalize_callback( $specs, $options->{normalize_keys} );
         $p     = _normalize_callback( $p,     $options->{normalize_keys} );
     }
     elsif ( $options->{ignore_case} || $options->{strip_leading} ) {
         $specs = _normalize_named($specs);
         $p     = _normalize_named($p);
     }
 
     if ($Params::Validate::NO_VALIDATION) {
         return (
             wantarray
             ? (
 
                 (
                     map { $_ => $specs->{$_}->{default} }
                         grep {
                         ref $specs->{$_}
                             && exists $specs->{$_}->{default}
                         }
                         keys %$specs
                 ),
                 (
                     ref $p eq 'ARRAY'
                     ? (
                         ref $p->[0]
                         ? %{ $p->[0] }
                         : @$p
                         )
                     : %$p
                 )
                 )
             : do {
                 my $ref = (
                     ref $p eq 'ARRAY'
                     ? (
                         ref $p->[0]
                         ? $p->[0]
                         : {@$p}
                         )
                     : $p
                 );
 
                 foreach (
                     grep {
                         ref $specs->{$_}
                             && exists $specs->{$_}->{default}
                     }
                     keys %$specs
                     ) {
                     $ref->{$_} = $specs->{$_}->{default}
                         unless exists $ref->{$_};
                 }
 
                 return $ref;
                 }
         );
     }
 
     _validate_named_depends( $p, $specs );
 
     unless ( $options->{allow_extra} ) {
         if ( my @unmentioned = grep { !exists $specs->{$_} } keys %$p ) {
             my $called = _get_called();
 
             $options->{on_fail}->( "The following parameter"
                     . ( @unmentioned > 1 ? 's were' : ' was' )
                     . " passed in the call to $called but "
                     . ( @unmentioned > 1 ? 'were' : 'was' )
                     . " not listed in the validation options: @unmentioned\n"
             );
         }
     }
 
     my @missing;
 
     keys %$specs;
 OUTER:
     while ( my ( $key, $spec ) = each %$specs ) {
         if (
             !exists $p->{$key}
             && (
                 ref $spec
                 ? !(
                     do {
 
                         if ( exists $spec->{default} ) {
                             $p->{$key} = $spec->{default};
                             next OUTER;
                         }
                     }
                     || do {
 
                         next OUTER if $spec->{optional};
                     }
                 )
                 : $spec
             )
             ) {
             push @missing, $key;
         }
 
         elsif ( ref $spec ) {
             my $value = defined $p->{$key} ? qq|"$p->{$key}"| : 'undef';
             _validate_one_param(
                 $p->{$key}, $p, $spec,
                 qq{The '$key' parameter (%s)}
             );
         }
     }
 
     if (@missing) {
         my $called = _get_called();
 
         my $missing = join ', ', map {"'$_'"} @missing;
         $options->{on_fail}->( "Mandatory parameter"
                 . ( @missing > 1 ? 's' : '' )
                 . " $missing missing in call to $called\n" );
     }
 
     foreach my $key (
         grep {
                    defined $p->{$_}
                 && !ref $p->{$_}
                 && ref $specs->{$_}
                 && $specs->{$_}{untaint}
         }
         keys %$p
         ) {
         ( $p->{$key} ) = $p->{$key} =~ /(.+)/;
     }
 
     return wantarray ? %$p : $p;
 }
 
 sub validate_with {
     return if $Params::Validate::NO_VALIDATION && !defined wantarray;
 
     my %p = @_;
 
     local $options = _get_options( ( caller(0) )[0], %p );
 
     unless ($Params::Validate::NO_VALIDATION) {
         unless ( exists $options->{called} ) {
             $options->{called} = ( caller( $options->{stack_skip} ) )[3];
         }
 
     }
 
     if ( UNIVERSAL::isa( $p{spec}, 'ARRAY' ) ) {
         return validate_pos( @{ $p{params} }, @{ $p{spec} } );
     }
     else {
 
         return &validate( $p{params}, $p{spec} );
     }
 }
 
 sub _normalize_callback {
     my ( $p, $func ) = @_;
 
     my %new;
 
     foreach my $key ( keys %$p ) {
         my $new_key = $func->($key);
 
         unless ( defined $new_key ) {
             die
                 "The normalize_keys callback did not return a defined value when normalizing the key '$key'";
         }
 
         if ( exists $new{$new_key} ) {
             die
                 "The normalize_keys callback returned a key that already exists, '$new_key', when normalizing the key '$key'";
         }
 
         $new{$new_key} = $p->{$key};
     }
 
     return \%new;
 }
 
 sub _normalize_named {
 
     my %h = ( ref $_[0] ) =~ /ARRAY/ ? @{ $_[0] } : %{ $_[0] };
 
     if ( $options->{ignore_case} ) {
         $h{ lc $_ } = delete $h{$_} for keys %h;
     }
 
     if ( $options->{strip_leading} ) {
         foreach my $key ( keys %h ) {
             my $new;
             ( $new = $key ) =~ s/^\Q$options->{strip_leading}\E//;
             $h{$new} = delete $h{$key};
         }
     }
 
     return \%h;
 }
 
 my %Valid = map { $_ => 1 }
     qw( callbacks can default depends isa optional regex type untaint  );
 
 sub _validate_one_param {
     my ( $value, $params, $spec, $id ) = @_;
 
 
     if ( exists $spec->{type} ) {
         unless ( defined $spec->{type}
             && Scalar::Util::looks_like_number( $spec->{type} )
             && $spec->{type} > 0 ) {
             my $msg
                 = "$id has a type specification which is not a number. It is ";
             if ( defined $spec->{type} ) {
                 $msg .= "a string - $spec->{type}";
             }
             else {
                 $msg .= "undef";
             }
 
             $msg
                 .= ".\n Use the constants exported by Params::Validate to declare types.";
 
             $options->{on_fail}->( sprintf( $msg, _stringify($value) ) );
         }
 
         unless ( _get_type($value) & $spec->{type} ) {
             my $type = _get_type($value);
 
             my @is      = _typemask_to_strings($type);
             my @allowed = _typemask_to_strings( $spec->{type} );
             my $article = $is[0] =~ /^[aeiou]/i ? 'an' : 'a';
 
             my $called = _get_called(1);
 
             $options->{on_fail}->(
                 sprintf(
                     "$id to $called was $article '@is', which "
                         . "is not one of the allowed types: @allowed\n",
                     _stringify($value)
                 )
             );
         }
     }
 
     return
         unless ( $spec->{isa}
         || $spec->{can}
         || $spec->{callbacks}
         || $spec->{regex} );
 
     if ( exists $spec->{isa} ) {
         foreach ( ref $spec->{isa} ? @{ $spec->{isa} } : $spec->{isa} ) {
             unless (
                 do {
                     local $@ = q{};
                     eval { $value->isa($_) };
                 }
                 ) {
                 my $is = ref $value ? ref $value : 'plain scalar';
                 my $article1 = $_ =~ /^[aeiou]/i  ? 'an' : 'a';
                 my $article2 = $is =~ /^[aeiou]/i ? 'an' : 'a';
 
                 my $called = _get_called(1);
 
                 $options->{on_fail}->(
                     sprintf(
                               "$id to $called was not $article1 '$_' "
                             . "(it is $article2 $is)\n", _stringify($value)
                     )
                 );
             }
         }
     }
 
     if ( exists $spec->{can} ) {
         foreach ( ref $spec->{can} ? @{ $spec->{can} } : $spec->{can} ) {
             unless (
                 do {
                     local $@ = q{};
                     eval { $value->can($_) };
                 }
                 ) {
                 my $called = _get_called(1);
 
                 $options->{on_fail}->(
                     sprintf(
                         "$id to $called does not have the method: '$_'\n",
                         _stringify($value)
                     )
                 );
             }
         }
     }
 
     if ( $spec->{callbacks} ) {
         unless ( UNIVERSAL::isa( $spec->{callbacks}, 'HASH' ) ) {
             my $called = _get_called(1);
 
             $options->{on_fail}->(
                 "'callbacks' validation parameter for $called must be a hash reference\n"
             );
         }
 
         foreach ( keys %{ $spec->{callbacks} } ) {
             unless ( UNIVERSAL::isa( $spec->{callbacks}{$_}, 'CODE' ) ) {
                 my $called = _get_called(1);
 
                 $options->{on_fail}->(
                     "callback '$_' for $called is not a subroutine reference\n"
                 );
             }
 
             my $ok;
             my $e = do {
                 local $@ = q{};
                 local $SIG{__DIE__};
                 $ok = eval { $spec->{callbacks}{$_}->( $value, $params ) };
                 $@;
             };
 
             if ( !$ok ) {
                 my $called = _get_called(1);
 
                 if ( ref $e ) {
                     $options->{on_fail}->($e);
                 }
                 else {
                     my $msg = "$id to $called did not pass the '$_' callback";
                     $msg .= ": $e" if length $e;
                     $msg .= "\n";
                     $options->{on_fail}->( sprintf( $msg, _stringify($value) ) );
                 }
             }
         }
     }
 
     if ( exists $spec->{regex} ) {
         unless ( ( defined $value ? $value : '' ) =~ /$spec->{regex}/ ) {
             my $called = _get_called(1);
 
             $options->{on_fail}->(
                 sprintf(
                     "$id to $called did not pass regex check\n",
                     _stringify($value)
                 )
             );
         }
     }
 }
 
 {
     my %isas = (
         'ARRAY'  => ARRAYREF,
         'HASH'   => HASHREF,
         'CODE'   => CODEREF,
         'GLOB'   => GLOBREF,
         'SCALAR' => SCALARREF,
         'REGEXP' => SCALARREF,
     );
     my %simple_refs = map { $_ => 1 } keys %isas;
 
     sub _get_type {
         return UNDEF unless defined $_[0];
 
         my $ref = ref $_[0];
         unless ($ref) {
 
             return GLOB if UNIVERSAL::isa( \$_[0], 'GLOB' );
             return SCALAR;
         }
 
         return $isas{$ref} if $simple_refs{$ref};
 
         foreach ( keys %isas ) {
             return $isas{$_} | OBJECT if UNIVERSAL::isa( $_[0], $_ );
         }
 
         return UNKNOWN;
     }
 }
 
 {
     my %type_to_string = (
         SCALAR()    => 'scalar',
         ARRAYREF()  => 'arrayref',
         HASHREF()   => 'hashref',
         CODEREF()   => 'coderef',
         GLOB()      => 'glob',
         GLOBREF()   => 'globref',
         SCALARREF() => 'scalarref',
         UNDEF()     => 'undef',
         OBJECT()    => 'object',
         UNKNOWN()   => 'unknown',
     );
 
     sub _typemask_to_strings {
         my $mask = shift;
 
         my @types;
         foreach (
             SCALAR,    ARRAYREF, HASHREF, CODEREF, GLOB, GLOBREF,
             SCALARREF, UNDEF,    OBJECT,  UNKNOWN
             ) {
             push @types, $type_to_string{$_} if $mask & $_;
         }
         return @types ? @types : ('unknown');
     }
 }
 
 {
     my %defaults = (
         ignore_case   => 0,
         strip_leading => 0,
         allow_extra   => 0,
         on_fail       => sub {
             require Carp;
             Carp::confess( $_[0] );
         },
         stack_skip     => 1,
         normalize_keys => undef,
     );
 
     *set_options = \&validation_options;
 
     sub validation_options {
         my %opts = @_;
 
         my $caller = caller;
 
         foreach ( keys %defaults ) {
             $opts{$_} = $defaults{$_} unless exists $opts{$_};
         }
 
         $Params::Validate::OPTIONS{$caller} = \%opts;
     }
 
     sub _get_options {
         my $caller = shift;
 
         if (@_) {
 
             return (
                 $Params::Validate::OPTIONS{$caller}
                 ? {
                     %{ $Params::Validate::OPTIONS{$caller} },
                     @_
                     }
                 : { %defaults, @_ }
             );
         }
         else {
             return (
                 exists $Params::Validate::OPTIONS{$caller}
                 ? $Params::Validate::OPTIONS{$caller}
                 : \%defaults
             );
         }
     }
 }
 
 sub _get_called {
     my $extra_skip = $_[0] || 0;
 
     $extra_skip++;
 
     my $called = (
         exists $options->{called}
         ? $options->{called}
         : ( caller( $options->{stack_skip} + $extra_skip ) )[3]
     );
 
     $called = 'N/A' unless defined $called;
 
     return $called;
 }
 
 sub _stringify {
     return defined $_[0] ? qq{"$_[0]"} : 'undef';
 }
 
 1;
### Params/Validate/XS.pm ###
 package Params::Validate::XS;
 
 use strict;
 use warnings;
 
 our $VERSION = '1.21';
 
 use Carp;
 
 my $default_fail = sub {
     Carp::confess( $_[0] );
 };
 
 {
     my %defaults = (
         ignore_case    => 0,
         strip_leading  => 0,
         allow_extra    => 0,
         on_fail        => $default_fail,
         stack_skip     => 1,
         normalize_keys => undef,
     );
 
     *set_options = \&validation_options;
 
     sub validation_options {
         my %opts = @_;
 
         my $caller = caller;
 
         foreach ( keys %defaults ) {
             $opts{$_} = $defaults{$_} unless exists $opts{$_};
         }
 
         $Params::Validate::OPTIONS{$caller} = \%opts;
     }
 
     use XSLoader;
     XSLoader::load(
         __PACKAGE__,
         exists $Params::Validate::XS::{VERSION}
         ? ${ $Params::Validate::XS::{VERSION} }
         : (),
     );
 }
 
 sub _check_regex_from_xs {
     return ( defined $_[0] ? $_[0] : '' ) =~ /$_[1]/ ? 1 : 0;
 }
 
 1;
### Parse/VarName.pm ###
 package Parse::VarName;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.02'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Exporter::Lite;
 our @EXPORT_OK = qw(split_varname_words);
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'Routines to parse variable name',
 };
 
 my @res;
 
 $SPEC{split_varname_words} = {
     v => 1.1,
     summary => 'Split words found in variable name',
     description => <<'_',
 
 Try to split words found in a variable name, e.g. mTime -> [m, Time], foo1Bar ->
 [foo, 1, Bar], Foo::barBaz::Qux2 -> [Foo, bar, Baz, Qux, 2].
 
 _
     args => {
         varname => {
             schema => 'str*',
             req => 1,
             pos => 1,
         },
         include_sep => {
             summary => 'Whether to include non-alphanum separator in result',
             description => <<'_',
 
 For example, under include_sep=true, Foo::barBaz::Qux2 -> [Foo, ::, bar, Baz,
 ::, Qux, 2].
 
 _
             schema => [bool => {default=>0}],
         },
     },
     result_naked => 1,
 };
 sub split_varname_words {
     my %args = @_;
     my $v = $args{varname} or return [400, "Please specify varname"];
 
     @res = ();
     $v =~ m!\A(?:
                 (
                     [A-Z][A-Z]+ |
                     [A-Z][a-z]+ |
                     [a-z]+ |
                     [0-9]+ |
                     [^A-Za-z0-9]+
                 )
                 (?{ push @res, $1 })
             )+\z!sxg
                 or return [];
     unless ($args{include_sep}) {
         @res = grep {/[A-Za-z0-9]/} @res;
     }
 
     \@res;
 }
 
 1;
 
 __END__
 
### Perinci/Access.pm ###
 package Perinci::Access;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.43'; 
 
 use 5.010001;
 use strict;
 use warnings;
 use Log::Any::IfLOG '$log';
 
 use Scalar::Util qw(blessed);
 use URI::Split qw(uri_split uri_join);
 
 our $Log_Request  = $ENV{LOG_RIAP_REQUEST}  // 0;
 our $Log_Response = $ENV{LOG_RIAP_RESPONSE} // 0;
 
 sub new {
     my ($class, %opts) = @_;
 
     $opts{riap_version}           //= 1.1;
     $opts{handlers}               //= {};
     $opts{handlers}{''}           //= 'Perinci::Access::Schemeless';
     $opts{handlers}{pl}           //= 'Perinci::Access::Perl';
     $opts{handlers}{http}         //= 'Perinci::Access::HTTP::Client';
     $opts{handlers}{https}        //= 'Perinci::Access::HTTP::Client';
     $opts{handlers}{'riap+tcp'}   //= 'Perinci::Access::Simple::Client';
     $opts{handlers}{'riap+unix'}  //= 'Perinci::Access::Simple::Client';
     $opts{handlers}{'riap+pipe'}  //= 'Perinci::Access::Simple::Client';
 
     $opts{_handler_objs}          //= {};
     bless \%opts, $class;
 }
 
 sub _request_or_parse_url {
     my $self = shift;
     my $which = shift;
 
     my ($action, $uri, $extra, $copts);
     if ($which eq 'request') {
         ($action, $uri, $extra, $copts) = @_;
     } else {
         ($uri, $copts) = @_;
     }
 
     my ($sch, $auth, $path, $query, $frag) = uri_split($uri);
     $sch //= "";
     die "Can't handle scheme '$sch' in URL" unless $self->{handlers}{$sch};
 
     if ($sch eq 'riap') {
         $auth //= '';
         die "Unsupported auth '$auth' in riap: scheme, ".
             "only 'perl' is supported" unless $auth eq 'perl';
         $sch = 'pl';
         $auth = undef;
         $uri = uri_join($sch, $auth, $path, $query, $frag);
     }
 
     unless ($self->{_handler_objs}{$sch}) {
         if (blessed($self->{handlers}{$sch})) {
             $self->{_handler_objs}{$sch} = $self->{handlers}{$sch};
         } else {
             my $modp = $self->{handlers}{$sch};
             $modp =~ s!::!/!g; $modp .= ".pm";
             require $modp;
             $self->{_handler_objs}{$sch} = $self->{handlers}{$sch}->new(
                 riap_version => $self->{riap_version},
                 %{ $self->{handler_args} // {}});
         }
     }
 
     my $res;
     if ($which eq 'request') {
         if ($Log_Request && $log->is_trace) {
             $log->tracef(
                 "Riap request (%s): %s -> %s (%s)",
                 ref($self->{_handler_objs}{$sch}),
                 $action, $uri, $extra, $copts);
         }
         $res = $self->{_handler_objs}{$sch}->request(
             $action, $uri, $extra, $copts);
         if ($Log_Response && $log->is_trace) {
             $log->tracef("Riap response: %s", $res);
         }
     } else {
         $res = $self->{_handler_objs}{$sch}->parse_url($uri, $copts);
     }
     $res;
 }
 
 sub request {
     my $self = shift;
     $self->_request_or_parse_url('request', @_);
 }
 
 sub parse_url {
     my $self = shift;
     $self->_request_or_parse_url('parse_url', @_);
 }
 
 1;
 
 __END__
 
### Perinci/Access/Base.pm ###
 package Perinci::Access::Base;
 
 use 5.010001;
 use strict;
 use warnings;
 
 use URI::Split qw(uri_split);
 
 our $VERSION = '0.33'; 
 
 sub new {
     my ($class, %opts) = @_;
     $opts{riap_version} //= 1.1;
     bless \%opts, $class;
 }
 
 our $re_var     = qr/\A[A-Za-z_][A-Za-z_0-9]*\z/;
 our $re_req_key = $re_var;
 our $re_action  = $re_var;
 
 sub check_request {
     my ($self, $req) = @_;
 
 
 
     $req->{v} //= 1.1;
     return [500, "Protocol version not supported"]
         if $req->{v} ne '1.1' && $req->{v} ne '1.2';
 
     my $action = $req->{action};
     return [400, "Please specify action"] unless $action;
     return [400, "Invalid action, please only use letters/numbers"]
         unless $action =~ $re_action;
 
     if (defined $req->{uri}) {
         ($req->{-uri_scheme}, $req->{-uri_auth}, $req->{-uri_path},
          $req->{-uri_query}, $req->{-uri_frag}) = uri_split($req->{uri});
     }
 
     0;
 }
 
 1;
 
 __END__
 
### Perinci/Access/HTTP/Client.pm ###
 package Perinci::Access::HTTP::Client;
 
 our $DATE = '2015-09-06'; 
 our $VERSION = '0.22'; 
 
 use 5.010001;
 use strict;
 use warnings;
 use experimental 'smartmatch';
 use Log::Any '$log';
 
 use Perinci::AccessUtil qw(strip_riap_stuffs_from_res);
 use Scalar::Util qw(blessed);
 
 use parent qw(Perinci::Access::Base);
 
 my @logging_methods = Log::Any->logging_methods();
 
 sub new {
     my $class = shift;
 
     my $self = $class->SUPER::new(@_);
 
     $self->{retries}         //= 2;
     $self->{retry_delay}     //= 3;
     unless (defined $self->{log_level}) {
         $self->{log_level} =
             $ENV{TRACE} ? 6 :
                 $ENV{DEBUG} ? 5 :
                     $ENV{VERBOSE} ? 4 :
                         $ENV{QUIET} ? 2 :
                             0;
     }
     $self->{log_callback}    //= undef;
     $self->{ssl_cert_file}   //= $ENV{SSL_CERT_FILE};
     $self->{ssl_ca_file}     //= $ENV{SSL_CA_FILE};
     $self->{user}            //= $ENV{PERINCI_HTTP_USER};
     $self->{password}        //= $ENV{PERINCI_HTTP_PASSWORD};
 
     $self;
 }
 
 sub _init {}
 
 sub request {
     my ($self, $action, $server_url, $extra, $copts) = @_;
     $extra //= {};
     $copts //= {};
     $log->tracef(
         "=> %s\::request(action=%s, server_url=%s, extra=%s)",
         __PACKAGE__, $action, $server_url, $extra);
     return [400, "Please specify server_url"] unless $server_url;
     my $rreq = { v=>$self->{riap_version},
                  action=>$action,
                  ua=>"Perinci/".($Perinci::Access::HTTP::Client::VERSION//"?"),
                  %$extra };
     my $res = $self->check_request($rreq);
     return $res if $res;
 
     state $json = do {
         require JSON;
         JSON->new->allow_nonref;
     };
 
     state $ua;
     state $callback = sub {
         my ($resp, $ua, $h, $data) = @_;
 
 
 
         if ($ua->{__mark}) {
             $ua->{__buffer} .= $data;
             if ($ua->{__buffer} =~ /\A([lr])(\d+) /) {
                 my ($chtype, $chlen) = ($1, $2);
                 my $hlen = 1+length($chlen)+1;
                 return 1 unless length($ua->{__buffer}) >= $hlen + $chlen;
                 my $chdata = substr($ua->{__buffer}, $hlen, $chlen);
                 substr($ua->{__buffer}, 0, $hlen+$chlen) = "";
                 if ($chtype eq 'l') {
                     if ($self->{log_callback}) {
                         $self->{log_callback}->($chdata);
                     } else {
                         $chdata =~ s/^\[(\w+)\]//;
                         my $method = $1;
                         $method = "error" unless $method ~~ @logging_methods;
                         $log->$method("[$server_url] $chdata");
                     }
                     return 1;
                 } elsif ($chtype eq 'r') {
                     $ua->{__body} .= $chdata;
                 } else {
                     $ua->{__body} = "[500,\"Unknown chunk type $chtype".
                         "try updating ${\(__PACKAGE__)} version\"]";
                     return 0;
                 }
             } else {
                 $ua->{__body} = "[500,\"Invalid response from server,".
                     " server is probably using older version of ".
                         "Riap::HTTP server library\"]";
                 return 0;
             }
         } else {
             $ua->{__body} .= $data;
         }
     };
 
     if (!$ua) {
         require LWP::UserAgent;
         $ua = LWP::UserAgent->new(
             ssl_opts => {
                 SSL_cert_file => $self->{ssl_cert_file},
                 SSL_ca_file   => $self->{ssl_ca_file},
             },
         );
         $ua->env_proxy;
         $ua->set_my_handler(
             "request_send", sub {
                 my ($req, $ua, $h) = @_;
                 $ua->{__buffer} = "";
                 $ua->{__body} = "";
             });
         $ua->set_my_handler(
             "response_header", sub {
                 my ($resp, $ua, $h) = @_;
                 if ($resp->header('x-riap-logging')) {
                     $ua->{__mark} = 1;
                 } else {
                     $ua->{__log_level} = 0;
                 }
             });
         $ua->set_my_handler(
             "response_data", $callback);
     }
 
     my $authuser = $copts->{user}     // $self->{user};
     my $authpass = $copts->{password} // $self->{password};
     if (defined $authuser) {
         require URI;
         my $suri = URI->new($server_url);
         my $host = $suri->host;
         my $port = $suri->port;
         $ua->credentials(
             "$host:$port",
             $self->{realm} // "restricted area",
             $authuser,
             $authpass,
         );
     }
 
     my $http_req = HTTP::Request->new(POST => $server_url);
     for (keys %$rreq) {
         next if /\A(?:args|fmt|loglevel|_.*)\z/;
         my $hk = "x-riap-$_";
         my $hv = $rreq->{$_};
         if (!defined($hv) || ref($hv)) {
             $hk = "$hk-j-";
             $hv = $json->encode($hv);
         }
         $http_req->header($hk => $hv);
     }
     $ua->{__log_level} = $self->{log_level};
     $http_req->header('x-riap-loglevel' => $ua->{__log_level});
     $http_req->header('x-riap-fmt'      => 'json');
 
     my %args;
     if ($rreq->{args}) {
         for (keys %{$rreq->{args}}) {
             $args{$_} = $rreq->{args}{$_};
         }
     }
     my $args_s = $json->encode(\%args);
     $http_req->header('Content-Type' => 'application/json');
     $http_req->header('Content-Length' => length($args_s));
     $http_req->content($args_s);
 
 
     my $custom_lwp_imp;
     if ($server_url =~ m!\Ahttps?:/[^/]!i) { 
         require LWP::Protocol::http::SocketUnixAlt;
         $custom_lwp_imp = "LWP::Protocol::http::SocketUnixAlt";
     }
 
     my $attempts = 0;
     my $do_retry;
     my $http_res;
     while (1) {
         $do_retry = 0;
 
         my $old_imp;
         if ($custom_lwp_imp) {
             $old_imp = LWP::Protocol::implementor("http");
             LWP::Protocol::implementor("http", $custom_lwp_imp);
         }
 
         eval { $http_res = $ua->request($http_req) };
         my $eval_err = $@;
 
         if ($old_imp) {
             LWP::Protocol::implementor("http", $old_imp);
         }
 
         return [500, "Client died: $eval_err"] if $eval_err;
 
         if ($http_res->code >= 500) {
             $log->warnf("Network failure (%d - %s), retrying ...",
                         $http_res->code, $http_res->message);
             $do_retry++;
         }
 
         if ($do_retry && $attempts++ < $self->{retries}) {
             sleep $self->{retry_delay};
         } else {
             last;
         }
     }
 
     return [500, "Network failure: ".$http_res->code." - ".$http_res->message]
         unless $http_res->is_success;
 
     $callback->($http_res, $ua, undef, "") if length($ua->{__buffer});
 
     return [500, "Empty response from server (1)"]
         if !length($http_res->content);
     return [500, "Empty response from server (2)"]
         unless length($ua->{__body});
 
     eval {
         $log->tracef("body: %s", $ua->{__body});
         $res = $json->decode($ua->{__body});
     };
     my $eval_err = $@;
     return [500, "Invalid JSON from server: $eval_err"] if $eval_err;
 
     strip_riap_stuffs_from_res($res);
 }
 
 sub parse_url {
     require URI::Split;
 
     my ($self, $uri, $copts) = @_;
     die "Please specify url" unless $uri;
 
     my $res = $self->request(info => $uri, {}, $copts);
     die "Can't 'info' on $uri: $res->[0] - $res->[1]" unless $res->[0] == 200;
 
     my $resuri = $res->[2]{uri};
     my ($sch, $auth, $path) = URI::Split::uri_split($resuri);
     $sch //= "pl";
 
     {proto=>$sch, path=>$path};
 }
 
 1;
 
 __END__
 
### Perinci/Access/Lite.pm ###
 package Perinci::Access::Lite;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.11'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Perinci::AccessUtil qw(strip_riap_stuffs_from_res);
 
 sub new {
     my ($class, %args) = @_;
     $args{riap_version} //= 1.1;
     bless \%args, $class;
 }
 
 sub __package_exists {
     no strict 'refs';
 
     my $pkg = shift;
 
     return unless $pkg =~ /\A\w+(::\w+)*\z/;
     if ($pkg =~ s/::(\w+)\z//) {
         return !!${$pkg . "::"}{$1 . "::"};
     } else {
         return !!$::{$pkg . "::"};
     }
 }
 
 sub request {
     no strict 'refs';
 
     my ($self, $action, $url, $extra) = @_;
 
 
     $extra //= {};
 
     my $v = $extra->{v} // 1.1;
     if ($v ne '1.1' && $v ne '1.2') {
         return [501, "Riap protocol not supported, must be 1.1 or 1.2"];
     }
 
     my $res;
     if ($url =~ m!\A(?:pl:)?/(\w+(?:/\w+)*)/(\w*)\z!) {
         my ($mod_uripath, $func) = ($1, $2);
         (my $pkg = $mod_uripath) =~ s!/!::!g;
         my $mod_pm = "$mod_uripath.pm";
 
         my $pkg_exists;
 
       LOAD:
         {
             last if exists $INC{$mod_pm};
             $pkg_exists = __package_exists($pkg);
             last LOAD if $pkg =~ /\A(main)\z/;
             last if $pkg_exists && defined(${"$pkg\::VERSION"});
             eval { require $mod_pm };
             return [500, "Can't load module $pkg: $@"] if $@;
         }
 
         if ($action eq 'list') {
             return [501, "Action 'list' not implemented for ".
                         "non-package entities"]
                 if length($func);
             no strict 'refs';
             my $spec = \%{"$pkg\::SPEC"};
             return [200, "OK (list)", [grep {/\A\w+\z/} sort keys %$spec]];
         } elsif ($action eq 'info') {
             my $data = {
                 uri => "$mod_uripath/$func",
                 type => (!length($func) ? "package" :
                              $func =~ /\A\w+\z/ ? "function" :
                                  $func =~ /\A[\@\$\%]/ ? "variable" :
                                      "?"),
             };
             return [200, "OK (info)", $data];
         } elsif ($action eq 'meta' || $action eq 'call') {
             return [501, "Action 'call' not implemented for package entity"]
                 if !length($func) && $action eq 'call';
             my $meta;
             {
                 no strict 'refs';
                 if (length $func) {
                     $meta = ${"$pkg\::SPEC"}{$func}
                         or return [
                             500, "No metadata for '$url' (".
                                 ($pkg_exists ? "package '$pkg' exists, perhaps you mentioned '$pkg' somewhere without actually loading the module, or perhaps '$func' is a typo?" :
                                      "package '$pkg' doesn't exist, perhaps '$mod_uripath' or '$func' is a typo?") .
                                 ")"];
                 } else {
                     $meta = ${"$pkg\::SPEC"}{':package'} // {v=>1.1};
                 }
                 $meta->{entity_v}    //= ${"$pkg\::VERSION"};
                 $meta->{entity_date} //= ${"$pkg\::DATE"};
             }
 
             require Perinci::Sub::Normalize;
             $meta = Perinci::Sub::Normalize::normalize_function_metadata($meta);
             return [200, "OK ($action)", $meta] if $action eq 'meta';
 
             my $args = { %{$extra->{args} // {}} }; 
             if ($meta->{features} && $meta->{features}{progress}) {
                 require Progress::Any;
                 $args->{-progress} = Progress::Any->get_indicator;
             }
 
             my $aa = $meta->{args_as} // 'hash';
             my @args;
             if ($aa =~ /array/) {
                 require Perinci::Sub::ConvertArgs::Array;
                 my $convres = Perinci::Sub::ConvertArgs::Array::convert_args_to_array(
                     args => $args, meta => $meta,
                 );
                 return $convres unless $convres->[0] == 200;
                 if ($aa =~ /ref/) {
                     @args = ($convres->[2]);
                 } else {
                     @args = @{ $convres->[2] };
                 }
             } elsif ($aa eq 'hashref') {
                 @args = ({ %$args });
             } else {
                 @args = %$args;
             }
 
             {
                 no strict 'refs';
                 $res = &{"$pkg\::$func"}(@args);
             }
 
             if ($meta->{result_naked}) {
                 $res = [200, "OK (envelope added by ".__PACKAGE__.")", $res];
             }
 
             if (defined $res->[2]) {
                 if ($meta->{result} && $meta->{result}{schema} &&
                         $meta->{result}{schema}[0] eq 'buf') {
                     $res->[3]{'x.hint.result_binary'} = 1;
                 }
             }
 
         } else {
             return [501, "Unknown/unsupported action '$action'"];
         }
     } elsif ($url =~ m!\Ahttps?:/(/?)!i) {
         my $is_unix = !$1;
         my $ht;
         require JSON;
         state $json = JSON->new->allow_nonref;
         if ($is_unix) {
             require HTTP::Tiny::UNIX;
             $ht = HTTP::Tiny::UNIX->new;
         } else {
             require HTTP::Tiny;
             $ht = HTTP::Tiny->new;
         }
         my %headers = (
             "x-riap-v" => $self->{riap_version},
             "x-riap-action" => $action,
             "x-riap-fmt" => "json",
             "content-type" => "application/json",
         );
         my $args = $extra->{args} // {};
         for (keys %$extra) {
             next if /\Aargs\z/;
             $headers{"x-riap-$_"} = $extra->{$_};
         }
         my $htres = $ht->post(
             $url, {
                 headers => \%headers,
                 content => $json->encode($args),
             });
         return [500, "Network error: $htres->{status} - $htres->{reason}"]
             if $htres->{status} != 200;
         return [500, "Server error: didn't return JSON (".$htres->{headers}{'content-type'}.")"]
             unless $htres->{headers}{'content-type'} eq 'application/json';
         return [500, "Server error: didn't return Riap 1.1 response (".$htres->{headers}{'x-riap-v'}.")"]
             unless $htres->{headers}{'x-riap-v'} =~ /\A1\.1(\.\d+)?\z/;
         $res = $json->decode($htres->{content});
     } else {
         return [501, "Unsupported scheme or bad URL '$url'"];
     }
 
     strip_riap_stuffs_from_res($res);
 }
 
 1;
 
 __END__
 
### Perinci/Access/Perl.pm ###
 package Perinci::Access::Perl;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.84'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use URI::Split qw(uri_split);
 
 use parent qw(Perinci::Access::Schemeless);
 
 sub new {
     my $class = shift;
 
     my $self = $class->SUPER::new(@_);
 
     delete $self->{package_prefix};
 
     $self->{allow_schemes} = ['pl', ''];
     $self->{deny_schemes} = undef;
 
     $self;
 }
 
 sub parse_url {
     my ($self, $uri) = @_;
     die "Please specify url" unless $uri;
 
     my ($sch, $auth, $path) = uri_split($uri);
     $sch //= "";
 
     die "Only pl uri scheme is supported" unless $sch eq 'pl';
     {proto=>"pl", path=>$path};
 }
 
 1;
 
 __END__
 
### Perinci/Access/Schemeless.pm ###
 package Perinci::Access::Schemeless;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.84'; 
 
 use 5.010001;
 use strict;
 use warnings;
 use experimental 'smartmatch';
 use Log::Any::IfLOG '$log';
 
 use parent qw(Perinci::Access::Base);
 
 use List::Util qw(first);
 use Perinci::Object;
 use Perinci::Sub::Normalize qw(normalize_function_metadata);
 use Perinci::Sub::Util qw(err);
 use Scalar::Util qw(blessed);
 use Module::Path::More qw(module_path);
 use Package::MoreUtil qw(package_exists);
 use Tie::Cache;
 use URI::Split qw(uri_split uri_join);
 
 our $re_perl_package =
     qr/\A[A-Za-z_][A-Za-z_0-9]*(::[A-Za-z_][A-Za-z_0-9]*)*\z/;
 
 sub new {
     require Class::Inspector;
 
     my $class = shift;
     my $self = $class->SUPER::new(@_);
 
     my %typeacts = (
         package  => [],
         function => [],
         variable => [],
     ); 
 
     my @comacts;
     for my $meth (@{Class::Inspector->methods(ref $self)}) {
         next unless $meth =~ /^actionmeta_(.+)/;
         my $act = $1;
         my $meta = $self->$meth();
         $self->{_actionmetas}{$act} = $meta;
         for my $type (@{$meta->{applies_to}}) {
             if ($type eq '*') {
                 push @comacts, [$act, $meta];
             } else {
                 push @{$typeacts{$type}}, [$act, $meta];
             }
         }
     }
     for my $type (keys %typeacts) {
         $typeacts{$type} = { map {$_->[0] => $_->[1]}
                                  @{$typeacts{$type}}, @comacts };
     }
     $self->{_typeacts} = \%typeacts;
 
     $self->{cache_size}              //= 100; 
     $self->{wrap}                    //= 1;
     $self->{load}                    //= 1;
     $self->{set_function_properties} //= {};
     $self->{normalize_metadata}      //= 1;
     $self->{debug}                   //= $ENV{PERINCI_ACCESS_SCHEMELESS_DEBUG} // 0;
     $self->{accept_argv}             //= 1;
 
     if ($self->{cache_size} > 0) {
         my %metacache;
         tie %metacache, 'Tie::Cache', $self->{cache_size};
         $self->{_meta_cache} = \%metacache;
         my %codecache;
         tie %codecache, 'Tie::Cache', $self->{cache_size};
         $self->{_code_cache} = \%codecache;
     }
 
     $self;
 }
 
 sub _init {}
 
 sub __match_paths {
     my ($path, $paths) = @_;
 
     my $pathslash = $path =~ m!/\z! ? $path : "$path/";
 
     for (ref($paths) eq 'ARRAY' ? @$paths : $paths) {
         if (ref($_) eq 'Regexp') {
             return 1 if $path =~ $_;
         } else {
             if (m!/\z!) {
                 return 1 if $_ eq $pathslash || index($pathslash, $_) == 0;
             } else {
                 my $p = "$_/";
                 return 1 if $p eq $path || index($pathslash, $p) == 0;
             }
         }
     }
     0;
 }
 
 sub __match_paths2 {
     my ($path, $paths) = @_;
 
     my $pathslash = $path =~ m!/\z! ? $path : "$path/";
 
     for (ref($paths) eq 'ARRAY' ? @$paths : $paths) {
         if (ref($_) eq 'Regexp') {
             return 1;
         } else {
             if (m!/\z!) {
                 return 1 if $_ eq $pathslash || index($_, $pathslash) == 0 ||
                     index($pathslash, $_) == 0;
             } else {
                 my $p = "$_/";
                 return 1 if $p eq $path || index($p, $pathslash) == 0 ||
                     index($pathslash, $p) == 0 ;
             }
         }
     }
     0;
 }
 
 sub _parse_uri {
     my ($self, $req) = @_;
 
     my $path = $req->{-uri_path};
     if (defined $self->{allow_paths}) {
         my $allow;
         if ($self->{_actionmetas}{$req->{action}}{allow_request_parent_path}) {
             $allow = __match_paths2($path, $self->{allow_paths});
         } else {
             $allow = __match_paths($path, $self->{allow_paths});
         }
         return err(403, "Forbidden uri path (does not match allow_paths)")
             unless $allow;
     }
     if (defined($self->{deny_paths}) &&
             __match_paths($path, $self->{deny_paths})) {
         return err(403, "Forbidden uri path (matches deny_paths)");
     }
 
     my $sch = $req->{-uri_scheme} // "";
     if (defined($self->{allow_schemes}) && !($sch ~~ $self->{allow_schemes})) {
         return err(501,
                    "Unsupported uri scheme (does not match allow_schemes)");
     }
     if (defined($self->{deny_schemes}) && ($sch ~~ $self->{deny_schemes})) {
         return err(501, "Unsupported uri scheme (matches deny_schemes)");
     }
 
     my ($dir, $leaf, $perl_package);
     if ($path =~ m!(.*)/(.*)!) {
         $dir  = $1;
         $leaf = $2;
     } else {
         $dir  = $path;
         $leaf = '';
     }
     for ($perl_package) {
         $_ = $dir;
         s!^/+!!;
         s!/+!::!g;
         if (defined $self->{package_prefix}) {
             $_ = $self->{package_prefix} . (length($_) ? "::":"") . $_;
         }
     }
     return err(400, "Invalid perl package name: $perl_package")
         if $perl_package && $perl_package !~ $re_perl_package;
 
     my $type;
     if (length $leaf) {
         if ($leaf =~ /^[%\@\$]/) {
             $type = 'variable';
         } else {
             $type = 'function';
         }
     } else {
         $type = 'package';
         $req->{-uri_path} .= "/" unless $path =~ m!/\z!;
     }
 
     $req->{-uri_dir}      = $dir;
     $req->{-uri_leaf}     = $leaf;
     $req->{-perl_package} = $perl_package;
     $req->{-type}         = $type;
 
     return;
 }
 
 my %loadcache;
 tie %loadcache, 'Tie::Cache', 200;
 
 sub _load_module {
     my ($self, $req) = @_;
 
     my $pkg = $req->{-perl_package};
 
     return if !$pkg;
 
     unless ($self->{load}) {
         return if package_exists($pkg);
         return err(500, "Package $pkg does not exist");
     }
 
     my $module_p = $pkg;
     $module_p =~ s!::!/!g;
     $module_p .= ".pm";
 
     return if $INC{$module_p};
 
     return err(500, "Module $pkg has failed to load previously" .
                    $loadcache{$module_p} ?
                        ": $loadcache{$module_p}[0] - $loadcache{$module_p}[1]" :
                            "")
         if exists($INC{$module_p});
 
     return $loadcache{$module_p} if exists $loadcache{$module_p};
 
     my $res;
     {
         my $fullpath = module_path(module=>$pkg, find_pmc=>0, find_prefix=>1);
 
         my $pkg_exists = package_exists($pkg);
 
         if (!$fullpath) {
             last if $pkg_exists;
             $res = [404, "Can't find module or prefix path for package $pkg"];
             last;
         } elsif ($fullpath !~ /\.pm$/) {
             last if $pkg_exists;
             $res = [405, "Can only find a prefix path for package $pkg"];
             last;
         }
         eval { require $module_p };
         if ($@) {
             $res = [500, "Can't load module $pkg (probably compile error): $@"];
             last;
         }
         if ($self->{after_load}) {
             eval { $self->{after_load}($self, module=>$pkg) };
             $log->error("after_load for package $pkg dies: $@") if $@;
         }
     }
     $loadcache{$module_p} = $res;
     return $res;
 }
 
 sub __inject_entity_v_date {
     no strict 'refs';
 
     my ($req, $meta) = @_;
 
     my $pkg = $req->{-perl_package};
     unless (defined $meta->{entity_v}) {
         my $ver = ${"$pkg\::VERSION"};
         if (defined $ver) {
             $meta->{entity_v} = $ver;
         }
     }
     unless (defined $meta->{entity_date}) {
         my $date = ${"$pkg\::DATE"};
         if (defined $date) {
             $meta->{entity_date} = $date;
         }
     }
 }
 
 sub get_meta {
     no strict 'refs';
 
     my ($self, $req) = @_;
 
     my $pkg  = $req->{-perl_package};
     my $leaf = $req->{-uri_leaf};
     my $type = $req->{-type};
     if (!length($pkg)) {
         if (length $leaf) {
             return [404, "No metadata for ::$leaf (".
                 (package_exists($pkg) ? "package '$pkg' exists, perhaps you mentioned '$pkg' somewhere without actually loading the module, or perhaps '$leaf' is a typo?" :
                      "package '$pkg' doesn't exist, perhaps '$pkg' or '$leaf' is a typo?").
                     ")"
             ];
         } else {
             $req->{-meta} = {v=>1.1};
             return;
         }
     }
 
     my $name = "$pkg\::$leaf";
     if ($self->{_meta_cache}{$name}) {
         $req->{-meta} = $self->{_meta_cache}{$name};
         return;
     }
 
     my $res = $self->_load_module($req);
     return $res if $res && !($type eq 'package' && $res->[0] == 405);
 
     my $meta;
     my $metas = \%{"$pkg\::SPEC"};
     $meta = $metas->{ $leaf || ":package" };
 
     if (!$meta && $type eq 'package') {
         $meta = {v=>1.1};
     }
 
     return err(404,
                join("",
                     "No metadata for $name (package '$pkg' exists, ",
                     "perhaps you mentioned '$pkg' ",
                     "somewhere without actually loading the module, or ",
                     "perhaps '$leaf' is a typo?)",
                 )) unless $meta;
 
     if ($res) {
         if ($res->[0] == 405) {
             $meta = {v=>1.1}; 
         } elsif ($res->[0] != 200) {
             return $res;
         }
     }
 
     if ($type eq 'function' && $self->{normalize_metadata}) {
         eval { $meta = normalize_function_metadata($meta) };
         if ($@) {
             return [500, "Can't normalize function metadata: $@"];
         }
 
         $meta->{args} //= {};
         $meta->{args_as} = 'hash';
         $meta->{result_naked} = 0;
         my $sfp = $self->{set_function_properties};
         $meta->{$_} = $sfp->{$_} for keys %$sfp;
     }
 
     __inject_entity_v_date($req, $meta);
 
     if ($self->{cache_size} > 0) {
         $self->{_meta_cache}{$name} = $meta;
     }
 
     $req->{-meta} = $meta;
     return;
 }
 
 sub get_code {
     my ($self, $req) = @_;
 
 
     my $name = $req->{-perl_package} . "::" . $req->{-uri_leaf};
     if ($self->{_code_cache}{$name}) {
         $req->{-code} = $self->{_code_cache}{$name};
         return;
     }
 
     my $res = $self->_load_module($req);
     return $res if $res;
 
     return err(404, "Can't find function $req->{-uri_leaf} in ".
                    "module $req->{-perl_package}")
         unless defined &{$name};
 
     my $meta;
     {
         no strict 'refs';
         my $metas = \%{"$req->{-perl_package}::SPEC"};
         $meta = $metas->{ $req->{-uri_leaf} || ":package" };
     }
 
     return err(404, "Can't find function metadata $req->{-uri_leaf} in ".
                    "module $req->{-perl_package}")
         unless $meta;
 
     my $code;
   GET_CODE:
     {
         if (!$self->{wrap} ||
                 $meta->{"x.perinci.sub.wrapper.logs"} &&
                     (first {$_->{validate_args}}
                          @{ $meta->{"x.perinci.sub.wrapper.logs"} })
             ) {
             $code = \&{$name};
             last GET_CODE;
         }
 
         require Perinci::Sub::Wrapper;
         my $wrapres = Perinci::Sub::Wrapper::wrap_sub(
             sub_name=>$name, meta=>$meta,
             convert=>{args_as=>'hash', result_naked=>0,
                       %{$self->{set_function_properties}},
                   });
         return err(500, "Can't wrap function", $wrapres)
             unless $wrapres->[0] == 200;
         $code = $wrapres->[2]{sub};
 
         if ($self->{cache_size} > 0) {
             $self->{_code_cache}{$name} = $code;
             my $meta   = $wrapres->[2]{meta};
             __inject_entity_v_date($req, $meta);
             $self->{_meta_cache}{$name} = $meta;
         }
     }
 
     $req->{-code} = $code;
     return;
 }
 
 sub request {
     no strict 'refs';
 
     my ($self, $action, $uri, $extra) = @_;
 
     return err(400, "Please specify URI") unless $uri;
 
     my $req = { action=>$action, uri=>$uri, %{$extra // {}} };
     my $res = $self->check_request($req);
     return $res if $res;
 
     return err(501, "Action '$action' not implemented")
         unless $self->can("actionmeta_$action");
 
     my $am = $self->${\("actionmeta_$action")};
 
     $res = $self->_parse_uri($req);
     return $res if $res;
 
     return err(501, "Action '$action' not implemented for ".
                    "'$req->{-type}' entity")
         unless $am->{applies_to}[0] eq '*' ||
             $req->{-type} ~~ @{ $am->{applies_to} };
 
     my $meth = "action_$action";
 
     $res = $self->$meth($req);
     if ($self->{debug}) {
         $res->[3] //= {};
         $res->[3]{debug} = {
             req => $req,
         };
     }
     $res;
 }
 
 sub parse_url {
     my ($self, $uri) = @_;
     die "Please specify url" unless $uri;
     my ($sch, $auth, $path) = uri_split($uri);
     return {
         proto=>'',
         path=>$path,
     };
 }
 
 sub actionmeta_info { +{
     applies_to => ['*'],
     summary    => "Get general information on code entity",
     needs_meta => 0,
     needs_code => 0,
 } }
 
 sub action_info {
     my ($self, $req) = @_;
 
     my $mres = $self->get_meta($req);
     return $mres if $mres;
 
     my $res = {
         uri  => $req->{uri},
         type => $req->{-type},
     };
 
     [200, "OK (info action)", $res];
 }
 
 sub actionmeta_actions { +{
     applies_to => ['*'],
     summary    => "List available actions for code entity",
     needs_meta => 0,
     needs_code => 0,
 } }
 
 sub action_actions {
     my ($self, $req) = @_;
 
     my $mres = $self->get_meta($req);
     return $mres if $mres;
 
     my @res;
     for my $k (sort keys %{ $self->{_typeacts}{$req->{-type}} }) {
         my $v = $self->{_typeacts}{$req->{-type}}{$k};
         if ($req->{detail}) {
             push @res, {name=>$k, summary=>$v->{summary}};
         } else {
             push @res, $k;
         }
     }
     [200, "OK (actions action)", \@res];
 }
 
 sub actionmeta_list { +{
     applies_to => ['package'],
     summary    => "List code entities inside this package code entity",
     allow_request_parent_path => 1,
 } }
 
 sub action_list {
     require Module::List;
 
     my ($self, $req) = @_;
     my $detail = $req->{detail};
     my $f_type = $req->{type} || "";
 
     my @res;
 
     my $filter_path = sub {
         my $path = shift;
         if (defined($self->{allow_paths}) &&
                 !__match_paths2($path, $self->{allow_paths})) {
             return 0;
         }
         if (defined($self->{deny_paths}) &&
                 __match_paths2($path, $self->{deny_paths})) {
             return 0;
         }
         1;
     };
 
     my %mem;
 
     unless ($f_type && $f_type ne 'package') {
         my $lres = Module::List::list_modules(
             $req->{-perl_package} ? "$req->{-perl_package}\::" : "",
             {list_modules=>1, list_prefixes=>1});
         my $dir = $req->{-uri_dir};
         for my $m (sort keys %$lres) {
             $m =~ s!::$!!;
             $m =~ s!.+::!!;
             my $path = "$dir/$m/";
             next unless $filter_path->($path);
             next if $mem{$path}++;
             if ($detail) {
                 push @res, {uri=>"$m/", type=>"package"};
             } else {
                 push @res, "$m/";
             }
         }
     }
 
     my $res = $self->_load_module($req);
     return $res if $res && $res->[0] != 405;
 
     no strict 'refs';
     my $spec = \%{"$req->{-perl_package}\::SPEC"};
     my $dir = $req->{-uri_dir};
     for my $e (sort keys %$spec) {
         next if $e =~ /^:/;
         my $path = "$dir/$e";
         next unless $filter_path->($path);
         next if $mem{$path}++;
         my $t = $e =~ /^[%\@\$]/ ? 'variable' : 'function';
         next if $f_type && $f_type ne $t;
         if ($detail) {
             push @res, {
                 uri=>$e, type=>$t,
             };
         } else {
             push @res, $e;
         }
     }
 
     [200, "OK (list action)", \@res];
 }
 
 sub actionmeta_meta { +{
     applies_to => ['*'],
     summary    => "Get metadata",
 } }
 
 sub action_meta {
     my ($self, $req) = @_;
 
     my $res = $self->get_meta($req);
     return $res if $res;
 
     [200, "OK (meta action)", $req->{-meta}];
 }
 
 sub actionmeta_call { +{
     applies_to => ['function'],
     summary    => "Call function",
 } }
 
 sub action_call {
     require UUID::Random;
 
     my ($self, $req) = @_;
 
     my $res;
 
     my $tm; 
     if (defined $req->{tx_id}) {
         $res = $self->_pre_tx_action($req);
         return $res if $res;
         $tm = $self->{_tx_manager};
         $tm->{_tx_id} = $req->{tx_id};
     }
 
     $res = $self->get_meta($req);
     return $res if $res;
     $res = $self->get_code($req);
     return $res if $res;
 
     my %args;
 
     if (exists($req->{argv}) && $self->{accept_argv}) {
         require Perinci::Sub::GetArgs::Argv;
         $res = Perinci::Sub::GetArgs::Argv::get_args_from_argv(
             argv => [@{ $req->{argv} }],
             meta => $req->{-meta},
         );
         return err(400, "Can't parse argv", $res) unless $res->[0] == 200;
         %args = %{ $res->[2] };
     } else {
         %args = %{ $req->{args} // {} };
     }
 
     my $risub = risub($req->{-meta});
 
     if ($req->{dry_run}) {
         return err(412, "Function does not support dry run")
             unless $risub->can_dry_run;
         if ($risub->feature('dry_run')) {
             $args{-dry_run} = 1;
         } else {
             $args{-dry_run} = 1;
             $args{-tx_action} = 'check_state';
             $args{-tx_action_id} = UUID::Random::generate();
             undef $tm;
         }
     }
 
     if ($risub->feature('progress')) {
         require Progress::Any;
         $args{-progress} = Progress::Any->get_indicator();
     }
 
     if ($tm) {
         $res = $tm->action(
             f => "$req->{-perl_package}::$req->{-uri_leaf}", args=>\%args,
             confirm => $req->{confirm},
         );
         $tm->{_tx_id} = undef if $tm;
     } else {
         $args{-confirm} = 1 if $req->{confirm};
         eval { $res = $req->{-code}->(%args) };
         my $eval_err = $@;
         if ($eval_err) {
             $res = err(500, "Function died: $eval_err");
         }
     }
 
     if (defined $res->[2]) {
         if ($req->{-meta}{result} && $req->{-meta}{result}{schema} &&
                 $req->{-meta}{result}{schema}[0] eq 'buf') {
             $res->[3]{'x.hint.result_binary'} = 1;
         }
     }
 
     $res;
 }
 
 sub actionmeta_complete_arg_val { +{
     applies_to => ['function'],
     summary    => "Complete function's argument value"
 } }
 
 sub action_complete_arg_val {
     require Perinci::Sub::Complete;
 
     my ($self, $req) = @_;
     my $arg = $req->{arg} or return err(400, "Please specify arg");
     my $word = $req->{word} // "";
     my $ci = $req->{ci};
 
     my $res = $self->get_meta($req);
     return $res if $res;
     [200, "OK (complete_arg_val action)",
      Perinci::Sub::Complete::complete_arg_val(meta=>$req->{-meta}, word=>$word,
                                               arg=>$arg, ci=>$ci) // []];
 }
 
 sub actionmeta_complete_arg_elem { +{
     applies_to => ['function'],
     summary    => "Complete function's argument element value"
 } }
 
 sub action_complete_arg_elem {
     require Perinci::Sub::Complete;
 
     my ($self, $req) = @_;
     my $arg = $req->{arg} or return err(400, "Please specify arg");
     defined(my $index = $req->{index})
         or return err(400, "Please specify index");
     my $word = $req->{word} // "";
     my $ci = $req->{ci};
 
     my $res = $self->get_meta($req);
     return $res if $res;
     [200, "OK (complete_arg_elem action)",
      Perinci::Sub::Complete::complete_arg_elem(
          meta=>$req->{-meta}, word=>$word, arg=>$arg, ci=>$ci, index=>$index,
      ) // []],
 }
 
 sub actionmeta_child_metas { +{
     applies_to => ['package'],
     summary    => "Get metadata of all child entities",
 } }
 
 sub action_child_metas {
     my ($self, $req) = @_;
 
     my $res = $self->action_list($req);
     return $res unless $res->[0] == 200;
     my $ents = $res->[2];
 
     my %res;
     my %om;
     my $base = uri_join(
         $req->{-uri_scheme}, $req->{-uri_auth}, $req->{-uri_dir});
 
     for my $ent (@$ents) {
         $res = $self->request(meta => "$base/$ent");
         next unless $res->[0] == 200;
         $res{$ent} = $res->[2];
     }
     [200, "OK (child_metas action)", \%res];
 }
 
 sub actionmeta_get { +{
     applies_to => ['variable'],
     summary    => "Get value of variable",
 } }
 
 sub action_get {
     no strict 'refs';
 
     my ($self, $req) = @_;
     local $req->{-uri_leaf} = $req->{-uri_leaf};
 
     $req->{-uri_leaf} =~ s/^([%\@\$])//
         or return err(500, "BUG: Unknown variable prefix");
     my $prefix = $1;
     my $name = $req->{-perl_package} . "::" . $req->{-uri_leaf};
     my $res =
         $prefix eq '$' ? ${$name} :
             $prefix eq '@' ? \@{$name} :
                 $prefix eq '%' ? \%{$name} :
                     undef;
     [200, "OK (get action)", $res];
 }
 
 sub _pre_tx_action {
     my ($self, $req) = @_;
 
     return err(501, "Transaction not supported by server")
         unless $self->{use_tx};
 
     if (ref($self->{custom_tx_manager}) eq 'CODE') {
         eval {
             $self->{_tx_manager} = $self->{custom_tx_manager}->($self);
             die $self->{_tx_manager} unless blessed($self->{_tx_manager});
         };
         return err(500, "Can't initialize custom tx manager: ".
                        "$self->{_tx_manager}: $@") if $@;
     } elsif (!blessed($self->{_tx_manager})) {
         my $tm_cl = $self->{custom_tx_manager} // "Perinci::Tx::Manager";
         my $tm_cl_p = $tm_cl; $tm_cl_p =~ s!::!/!g; $tm_cl_p .= ".pm";
         eval {
             require $tm_cl_p;
             $self->{_tx_manager} = $tm_cl->new(pa => $self);
             die $self->{_tx_manager} unless blessed($self->{_tx_manager});
         };
         return err(500, "Can't initialize tx manager ($tm_cl): $@") if $@;
         if ($tm_cl eq 'Perinci::Tx::Manager') {
             $Perinci::Tx::Manager::VERSION >= 0.29
                 or die "Your Perinci::Tx::Manager is too old, ".
                     "please install v0.29 or later";
         }
     }
 
     return;
 }
 
 sub actionmeta_begin_tx { +{
     applies_to => ['*'],
     summary    => "Start a new transaction",
 } }
 
 sub action_begin_tx {
     my ($self, $req) = @_;
     my $res = $self->_pre_tx_action($req);
     return $res if $res;
 
     $self->{_tx_manager}->begin(
         tx_id   => $req->{tx_id},
         summary => $req->{summary},
     );
 }
 
 sub actionmeta_commit_tx { +{
     applies_to => ['*'],
     summary    => "Commit a transaction",
 } }
 
 sub action_commit_tx {
     my ($self, $req) = @_;
     my $res = $self->_pre_tx_action($req);
     return $res if $res;
 
     $self->{_tx_manager}->commit(
         tx_id  => $req->{tx_id},
     );
 }
 
 sub actionmeta_savepoint_tx { +{
     applies_to => ['*'],
     summary    => "Create a savepoint in a transaction",
 } }
 
 sub action_savepoint_tx {
     my ($self, $req) = @_;
     my $res = $self->_pre_tx_action($req);
     return $res if $res;
 
     $self->{_tx_manager}->savepoint(
         tx_id => $req->{tx_id},
         sp    => $req->{tx_spid},
     );
 }
 
 sub actionmeta_release_tx_savepoint { +{
     applies_to => ['*'],
     summary    => "Release a transaction savepoint",
 } }
 
 sub action_release_tx_savepoint {
     my ($self, $req) =\ @_;
     my $res = $self->_pre_tx_action($req);
     return $res if $res;
 
     $self->{_tx_manager}->release_savepoint(
         tx_id => $req->{tx_id},
         sp    => $req->{tx_spid},
     );
 }
 
 sub actionmeta_rollback_tx { +{
     applies_to => ['*'],
     summary    => "Rollback a transaction (optionally to a savepoint)",
 } }
 
 sub action_rollback_tx {
     my ($self, $req) = @_;
     my $res = $self->_pre_tx_action($req);
     return $res if $res;
 
     $self->{_tx_manager}->rollback(
         tx_id => $req->{tx_id},
         sp    => $req->{tx_spid},
     );
 }
 
 sub actionmeta_list_txs { +{
     applies_to => ['*'],
     summary    => "List transactions",
 } }
 
 sub action_list_txs {
     my ($self, $req) = @_;
     my $res = $self->_pre_tx_action($req);
     return $res if $res;
 
     $self->{_tx_manager}->list(
         detail    => $req->{detail},
         tx_status => $req->{tx_status},
         tx_id     => $req->{tx_id},
     );
 }
 
 sub actionmeta_undo { +{
     applies_to => ['*'],
     summary    => "Undo a committed transaction",
 } }
 
 sub action_undo {
     my ($self, $req) = @_;
     my $res = $self->_pre_tx_action($req);
     return $res if $res;
 
     $self->{_tx_manager}->undo(
         tx_id   => $req->{tx_id},
         confirm => $req->{confirm},
     );
 }
 
 sub actionmeta_redo { +{
     applies_to => ['*'],
     summary    => "Redo an undone committed transaction",
 } }
 
 sub action_redo {
     my ($self, $req) = @_;
     my $res = $self->_pre_tx_action($req);
     return $res if $res;
 
     $self->{_tx_manager}->redo(
         tx_id   => $req->{tx_id},
         confirm => $req->{confirm},
     );
 }
 
 sub actionmeta_discard_tx { +{
     applies_to => ['*'],
     summary    => "Discard (forget) a committed transaction",
 } }
 
 sub action_discard_tx {
     my ($self, $req) = @_;
     my $res = $self->_pre_tx_action($req);
     return $res if $res;
 
     $self->{_tx_manager}->discard(
         tx_id => $req->{tx_id},
     );
 }
 
 sub actionmeta_discard_all_txs { +{
     applies_to => ['*'],
     summary    => "Discard (forget) all committed transactions",
 } }
 
 sub action_discard_all_txs {
     my ($self, $req) = @_;
     my $res = $self->_pre_tx_action($req);
     return $res if $res;
 
     $self->{_tx_manager}->discard_all(
     );
 }
 
 1;
 
 __END__
 
### Perinci/Access/Simple/Client.pm ###
 package Perinci::Access::Simple::Client;
 
 our $DATE = '2015-09-06'; 
 our $VERSION = '0.20'; 
 
 use 5.010001;
 use strict;
 use warnings;
 use Log::Any '$log';
 
 use Cwd qw(abs_path);
 use Perinci::AccessUtil qw(strip_riap_stuffs_from_res);
 use POSIX qw(:sys_wait_h);
 use Tie::Cache;
 use URI::Split qw(uri_split);
 use URI::Escape;
 
 use parent qw(Perinci::Access::Base);
 
 my @logging_methods = Log::Any->logging_methods();
 
 sub new {
     my $class = shift;
 
     my $self = $class->SUPER::new(@_);
 
     $self->{retries}         //= 2;
     $self->{retry_delay}     //= 3;
     $self->{conn_cache_size} //= 32;
 
     tie my(%conns), 'Tie::Cache', $self->{conn_cache_size};
     $self->{_conns} = \%conns;
 
     $self;
 }
 
 sub _init {}
 
 sub _delete_cache {
     my ($self, $wanted) = @_;
     my $conns = $self->{_conns};
     return unless $conns;
 
     for my $k ($wanted ? ($wanted) : (keys %$conns)) {
         if ($k =~ /^pipe:/) {
             waitpid($conns->{$k}{pid}, WNOHANG);
         }
         delete $self->{_conns}{$k};
     }
 }
 
 sub DESTROY {
     my ($self) = @_;
 
 }
 
 sub request {
     my $self = shift;
     $self->_parse_or_request('request', @_);
 }
 
 sub _parse {
     my $self = shift;
     $self->_parse_or_request('parse2', @_);
 }
 
 sub _parse_or_request {
     my ($self, $which, $action, $server_url, $extra) = @_;
     $log->tracef("=> %s\::request(action=%s, server_url=%s, extra=%s)",
                  __PACKAGE__, $action, $server_url, $extra);
     return [400, "Please specify server_url"] unless $server_url;
 
     my ($uri,
         $cache_key,
         $host, $port, 
         $path,        
         $args         
     );
     my ($srvsch, $srvauth, $srvpath, $srvquery, $srvfrag) =
         uri_split($server_url);
     $srvauth //= "";
     $srvpath //= "";
     return [400, "Please supply only riap+tcp/riap+unix/riap+pipe URL"]
         unless $srvsch =~ /\Ariap\+(tcp|unix|pipe)\z/;
     if ($srvsch eq 'riap+tcp') {
         if ($srvauth =~ m!^(.+):(\d+)$!) {
             ($host, $port) = ($1, $2, $3);
             $uri = $srvpath;
             $cache_key = "tcp:".lc($host).":$port";
         } else {
             return [400, "Invalid riap+tcp URL, please use this format: ".
                 "riap+tcp://host:1234 or riap+tcp://host:1234/uri"];
         }
     } elsif ($srvsch eq 'riap+unix') {
         if ($srvpath =~ m!(.+)/(/.*)!) {
             ($path, $uri) = (uri_unescape($1), $2);
         } elsif ($srvpath =~ m!(.+)!) {
             $path = uri_unescape($1);
         }
         unless ($which eq 'parse0') {
             if (defined($path)) {
                 my $apath = abs_path($path) or
                     return [500, "Can't find absolute path for $path"];
                 $cache_key = "unix:$apath";
             } else {
                 return [400, "Invalid riap+unix URL, please use this format: ".
                             ", e.g.: riap+unix:/path/to/unix/socket or ".
                                 "riap+unix:/path/to/unix/socket//uri"];
             }
         }
     } elsif ($srvsch eq 'riap+pipe') {
         if ($srvpath =~ m!(.+?)//(.*?)/(/.*)!) {
             ($path, $args, $uri) = (uri_unescape($1), $2, $3);
         } elsif ($srvpath =~ m!(.+?)//(.*)!) {
             ($path, $args) = (uri_unescape($1), $2);
         } elsif ($srvpath =~ m!(.+)!) {
             $path = uri_unescape($1);
             $args = '';
         }
         $args = [map {uri_unescape($_)} split m!/!, $args // ''];
         unless ($which eq 'parse0') {
             if (defined($path)) {
                 my $apath = abs_path($path) or
                     return [500, "Can't find absolute path for $path"];
                 $cache_key = "pipe:$apath ".join(" ", @$args);
             } else {
                 return [400, "Invalid riap+pipe URL, please use this format: ".
                             "riap+pipe:/path/to/prog or ".
                                 "riap+pipe:/path/to/prog//arg1/arg2 or ".
                                     "riap+pipe:/path/to/prog//arg1/arg2//uri"];
             }
         }
     }
 
     my $req;
     my $res;
 
     unless ($which eq 'parse0') {
         $req = { v=>$self->{riap_version}, action=>$action, %{$extra // {}} };
         $uri ||= $req->{uri}; $req->{uri} //= $uri;
         $res = $self->check_request($req);
         return $res if $res;
     }
 
     if ($which =~ /parse/) {
         return [200, "OK", {
             args=>$args, host=>$host, path=>$path, port=>$port,
             scheme=>$srvsch, uri=>$uri,
         }];
     }
 
     $log->tracef("Parsed URI, scheme=%s, host=%s, port=%s, path=%s, args=%s, ".
                      "uri=%s", $srvsch, $host, $port, $path, $args, $uri);
 
     require JSON;
     state $json = JSON->new->allow_nonref;
 
     my $attempts = 0;
     my $do_retry;
     my $e;
     while (1) {
         $do_retry = 0;
 
         my ($in, $out);
         my $cache = $self->{_conns}{$cache_key};
         if ($cache) {
             if ($srvsch =~ /tcp|unix/) {
                 if ($cache->{socket}->connected) {
                     $in = $out = $cache->{socket};
                 } else {
                     $log->infof("Stale socket cache (%s), discarded",
                                 $cache_key);
                     $cache = undef;
                 }
             } else {
                 if (kill(0, $cache->{pid})) {
                     $in  = $cache->{chld_out};
                     $out = $cache->{chld_in};
                 } else {
                     $log->infof(
                         "Process (%s) seems dead/unsignalable, discarded",
                         $cache_key);
                     $cache = undef;
                 }
             }
         }
         if (!$cache) {
             if ($srvsch =~ /tcp|unix/) {
                 my $sock;
                 if ($srvsch eq 'riap+tcp') {
                     require IO::Socket::INET;
                     $sock = IO::Socket::INET->new(
                         PeerHost => $host,
                         PeerPort => $port,
                         Proto    => 'tcp',
                     );
                 } else {
                     use IO::Socket::UNIX;
                     $sock = IO::Socket::UNIX->new(
                         Type => SOCK_STREAM,
                         Peer => $path,
                     );
                 }
                 $e = $@;
                 if ($sock) {
                     $self->{_conns}{$cache_key} = {socket=>$sock};
                     $in = $out = $sock;
                 } else {
                     $e = $srvsch eq 'riap+tcp' ?
                         "Can't connect to TCP socket $host:$port: $e" :
                             "Can't connect to Unix socket $path: $e";
                     $do_retry++; goto RETRY;
                 }
             } else {
                 require IO::File;
                 require IO::Handle;
 
                 require IPC::Open2;
 
                 require String::ShellQuote;
                 my $cmd = $path . (@$args ? " " . join(" ", map {
                     String::ShellQuote::shell_quote($_) } @$args) : "");
                 $log->tracef("executing cmd: %s", $cmd);
 
 
                 my $pid = IPC::Open2::open2($in, $out, $path, @$args);
 
                 if ($pid) {
                     $self->{_conns}{$cache_key} = {
                         pid=>$pid, chld_out=>$in, chld_in=>$out};
                 } else {
                     $e = "Can't open2 $cmd: $!";
                     $do_retry++; goto RETRY;
                 }
             }
         }
 
         my $req_json;
         eval { $req_json = $json->encode($req) };
         $e = $@;
         return [400, "Can't encode request as JSON: $e"] if $e;
 
         $out->write("j$req_json\015\012");
         $log->tracef("Sent request to server: %s", $req_json);
 
         my $line = $in->getline;
         $log->tracef("Got line from server: %s", $line);
         if (!$line) {
             $self->_delete_cache($cache_key);
             return [500, "Empty response from server"];
         } elsif ($line !~ /^j(.+)/) {
             $self->_delete_cache($cache_key);
             return [500, "Invalid response line from server: $line"];
         }
         eval { $res = $json->decode($1) };
         $e = $@;
         if ($e) {
             $self->_delete_cache($cache_key);
             return [500, "Invalid JSON response from server: $e"];
         }
         strip_riap_stuffs_from_res($res);
         return $res;
 
       RETRY:
         if ($do_retry && $attempts++ < $self->{retries}) {
             $log->tracef("Request failed ($e), waiting to retry #%s...",
                          $attempts);
             sleep $self->{retry_delay};
         } else {
             last;
         }
     }
     return [500, "$e (tried $attempts times)"];
 }
 
 sub request_tcp {
     my ($self, $action, $hostport, $extra) = @_;
     $self->request($action, "riap+tcp://$hostport->[0]:$hostport->[1]", $extra);
 }
 
 sub request_unix {
     my ($self, $action, $sockpath, $extra) = @_;
     $self->request($action => "riap+unix:" . uri_escape($sockpath), $extra);
 }
 
 sub request_pipe {
     my ($self, $action, $cmd, $extra) = @_;
     $self->request($action => "riap+pipe:" . uri_escape($cmd->[0]) . "//" .
                        join("/", map {uri_escape($_)} @$cmd[1..@$cmd-1]),
                    $extra);
 }
 
 sub parse_url {
     my ($self, $uri) = @_;
 
     my $res0 = $self->_parse_or_request('parse0', 'dummy', $uri);
     die "Can't parse URL $uri: $res0->[0] - $res0->[1]" unless $res0->[0]==200;
     $res0 = $res0->[2];
     my $res = {proto=>$res0->{scheme}, path=>$res0->{uri}};
     if ($res->{proto} eq 'riap+unix') {
         $res->{unix_sock_path} = $res0->{path};
     } elsif ($res->{proto} eq 'riap+tcp') {
         $res->{host} = $res0->{host};
         $res->{port} = $res0->{port};
     } elsif ($res->{proto} eq 'riap+pipe') {
         $res->{prog_path} = $res0->{path};
         $res->{args} = $res0->{args};
     }
 
     $res;
 }
 
 1;
 
 __END__
 
### Perinci/AccessUtil.pm ###
 package Perinci::AccessUtil;
 
 our $DATE = '2015-09-06'; 
 our $VERSION = '0.06'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use MIME::Base64;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(insert_riap_stuffs_to_res
                     strip_riap_stuffs_from_res
                     decode_args_in_riap_req);
 
 sub insert_riap_stuffs_to_res {
     my ($res, $def_ver, $nmeta, $encode) = @_;
 
     $res->[3]{'riap.v'} //= $def_ver // 1.1;
     if ($res->[3]{'riap.v'} >= 1.2) {
         {
             last unless $encode // 1;
             last if $res->[3]{'riap.result_encoding'};
             if ($nmeta) {
                 last unless $nmeta->{result}{schema} &&
                     $nmeta->{result}{schema}[0] eq 'buf';
             }
             last unless defined($res->[2]) && !ref($res->[2]) &&
                 $res->[2] =~ /[^\x20-\x7f]/;
             $res->[2] = encode_base64($res->[2], "");
             $res->[3]{'riap.result_encoding'} = 'base64';
         }
     }
     $res;
 }
 
 sub strip_riap_stuffs_from_res {
     my $res = shift;
 
     my $ver = $res->[3]{'riap.v'} // 1.1;
     return [501, "Riap version returned by server ($ver) is not supported, ".
                 "only recognize v1.1 and v1.2"]
         unless $ver == 1.1 || $ver == 1.2;
 
     if ($ver >= 1.2) {
         for my $k (keys %{$res->[3]}) {
             next unless $k =~ /\Ariap\./;
             my $val = $res->[3]{$k};
             if ($k eq 'riap.v') {
             } elsif ($k eq 'riap.result_encoding') {
                 return [501, "Unknown result_encoding returned by server ".
                             "($val), only base64 is supported"]
                     unless $val eq 'base64';
                 $res->[2] = decode_base64($res->[2]//'');
             } else {
                 return [501, "Unknown Riap attribute in result metadata ".
                             "returned by server ($k)"];
             }
             delete $res->[3]{$k};
         }
     }
 
     $res;
 }
 
 sub decode_args_in_riap_req {
     my $req = shift;
 
     my $v = $req->{v} // 1.1;
     if ($v >= 1.2) {
         if ($req->{args}) {
             my $args = $req->{args};
             for (keys %$args) {
                 next unless /\A(.+):base64\z/;
                 $args->{$1} = decode_base64($args->{$_});
                 delete $args->{$_};
             }
         }
     }
     $req;
 }
 
 1;
 
 __END__
 
### Perinci/CmdLine/Base.pm ###
 package Perinci::CmdLine::Base;
 
 our $DATE = '2015-10-20'; 
 our $VERSION = '1.36'; 
 
 use 5.010001;
 use strict;
 use warnings;
 use Log::Any::IfLOG '$log';
 
 
 BEGIN {
     if ($INC{'Perinci/CmdLine/Classic.pm'}) {
         require Moo; Moo->import;
     } else {
         require Mo; Mo->import(qw(build default));
     }
 }
 
 has actions => (is=>'rw');
 has common_opts => (is=>'rw');
 has completion => (is=>'rw');
 has default_subcommand => (is=>'rw');
 has get_subcommand_from_arg => (is=>'rw', default=>1);
 has description => (is=>'rw');
 has exit => (is=>'rw', default=>1);
 has formats => (is=>'rw');
 has pass_cmdline_object => (is=>'rw', default=>0);
 has per_arg_json => (is=>'rw');
 has per_arg_yaml => (is=>'rw');
 has program_name => (
     is=>'rw',
     default => sub {
         my $pn = $ENV{PERINCI_CMDLINE_PROGRAM_NAME};
         if (!defined($pn)) {
             $pn = $0; $pn =~ s!.+/!!;
         }
         $pn;
     });
 has riap_version => (is=>'rw', default=>1.1);
 has riap_client => (is=>'rw');
 has riap_client_args => (is=>'rw');
 has subcommands => (is=>'rw');
 has summary => (is=>'rw');
 has tags => (is=>'rw');
 has url => (is=>'rw');
 
 has read_env => (is=>'rw', default=>1);
 has env_name => (
     is => 'rw',
     lazy => 1,
     default => sub {
         my $self = shift;
         __default_env_name($self->program_name);
     },
 );
 
 has read_config => (is=>'rw', default=>1);
 has config_filename => (is=>'rw');
 has config_dirs => (
     is=>'rw',
     default => sub {
         require Perinci::CmdLine::Util::Config;
         Perinci::CmdLine::Util::Config::get_default_config_dirs();
     },
 );
 
 has cleanser => (
     is => 'rw',
     lazy => 1,
     default => sub {
         require Data::Clean::JSON;
         Data::Clean::JSON->get_cleanser;
     },
 );
 
 has extra_urls_for_version => (is=>'rw');
 
 has skip_format => (is=>'rw');
 
 
 
 our %copts = (
 
     version => {
         getopt  => "version|v",
         summary => "Display program's version and exit",
         usage   => "--version (or -v)",
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{action} = 'version';
             $r->{skip_parse_subcommand_argv} = 1;
         },
     },
 
     help => {
         getopt  => 'help|h|?',
         summary => 'Display help message and exit',
         usage   => "--help (or -h, -?)",
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{action} = 'help';
             $r->{skip_parse_subcommand_argv} = 1;
         },
         order => 0, 
     },
 
     format => {
         getopt  => 'format=s',
         summary => 'Choose output format, e.g. json, text',
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{format} = $val;
         },
         default => undef,
         tags => ['category:output'],
         is_settable_via_config => 1,
     },
     json => {
         getopt  => 'json',
         summary => 'Set output format to json',
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{format} = (-t STDOUT) ? 'json-pretty' : 'json';
         },
         tags => ['category:output'],
     },
 
     naked_res => {
         getopt  => 'naked-res!',
         summary => 'When outputing as JSON, strip result envelope',
         'summary.alt.bool.not' => 'When outputing as JSON, add result envelope',
         description => <<'_',
 
 By default, when outputing as JSON, the full enveloped result is returned, e.g.:
 
     [200,"OK",[1,2,3],{"func.extra"=>4}]
 
 The reason is so you can get the status (1st element), status message (2nd
 element) as well as result metadata/extra result (4th element) instead of just
 the result (3rd element). However, sometimes you want just the result, e.g. when
 you want to pipe the result for more post-processing. In this case you can use
 `--naked-res` so you just get:
 
     [1,2,3]
 
 _
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{naked_res} = $val ? 1:0;
         },
         default => 0,
         tags => ['category:output'],
         is_settable_via_config => 1,
     },
 
     subcommands => {
         getopt  => 'subcommands',
         summary => 'List available subcommands',
         usage   => "--subcommands",
         show_in_usage => sub {
             my ($self, $r) = @_;
             !$r->{subcommand_name};
         },
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{action} = 'subcommands';
             $r->{skip_parse_subcommand_argv} = 1;
         },
     },
 
     cmd => {
         getopt  => "cmd=s",
         summary => 'Select subcommand',
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{subcommand_name} = $val;
             $r->{subcommand_name_from} = '--cmd';
         },
         completion => sub {
             require Complete::Util;
             my %args = @_;
             my $cmdline = $args{cmdline};
             Complete::Util::complete_array_elem(
                 array => [keys %{ $cmdline->list_subcommands }],
                 word  => $args{word},
                 ci    => 1,
             );
         },
     },
 
     config_path => {
         getopt  => 'config-path=s@',
         schema  => ['array*', of => 'str*'],
         'x.schema.element_entity' => 'filename',
         summary => 'Set path to configuration file',
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{config_paths} //= [];
             push @{ $r->{config_paths} }, $val;
         },
         tags => ['category:configuration'],
     },
     no_config => {
         getopt  => 'no-config',
         summary => 'Do not use any configuration file',
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{read_config} = 0;
         },
         tags => ['category:configuration'],
     },
     no_env => {
         getopt  => 'no-env',
         summary => 'Do not read environment for default options',
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{read_env} = 0;
         },
         tags => ['category:environment'],
     },
     config_profile => {
         getopt  => 'config-profile=s',
         summary => 'Set configuration profile to use',
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{config_profile} = $val;
         },
         completion => sub {
 
             my %args = @_;
             my $word    = $args{word} // '';
             my $cmdline = $args{cmdline};
             my $r       = $args{r};
 
             return undef unless $cmdline;
 
             {
                 $r->{read_config} = 1;
 
                 my $res = $cmdline->parse_argv($r);
             }
 
             return [] unless $r->{config};
 
             my @profiles;
             for (keys %{$r->{config}}) {
                 if (length $r->{subcommand_name}) {
                     push @profiles, $1
                         if /\A\Q$r->{subcommand_name}\E \s+ profile=(.+)/x;
                 } else {
                     push @profiles, $1 if /\Aprofile=(.+)/;
                 }
             }
 
             require Complete::Util;
             Complete::Util::complete_array_elem(
                 array=>[sort @profiles], word=>$word, ci=>1);
         },
         tags => ['category:configuration'],
     },
 
     log_level => {
         getopt  => 'log-level=s',
         summary => 'Set log level (note: you also need to set LOG=1 to enable logging)',
         schema  => ['str*' => in => [
             qw/trace debug info warn warning error fatal/]],
         handler => sub {
             my ($go, $val, $r) = @_;
             $r->{log_level} = $val;
             $ENV{LOG_LEVEL} = $val;
         },
         is_settable_via_config => 1,
         tags => ['category:logging'],
     },
     trace => {
         getopt  => "trace",
         summary => "Set log level to trace (note: you also need to set LOG=1 to enable logging, or use TRACE=1)",
         handler => sub {
             my ($go, $val, $r) = @_;
             $ENV{TRACE} = 1;
         },
         tags => ['category:logging'],
     },
     debug => {
         getopt  => "debug",
         summary => "Set log level to debug (note: you also need to set LOG=1 to enable logging, or use DEBUG=1)",
         handler => sub {
             my ($go, $val, $r) = @_;
             $ENV{DEBUG} = 1;
         },
         tags => ['category:logging'],
     },
     verbose => {
         getopt  => "verbose",
         summary => "Set log level to info (note: you also need to set LOG=1 to enable logging, or use VERBOSE=1)",
         handler => sub {
             my ($go, $val, $r) = @_;
             $ENV{VERBOSE} = 1;
             $r->{_help_verbose} = 1;
         },
         tags => ['category:logging'],
     },
     quiet => {
         getopt  => "quiet",
         summary => "Set log level to quiet (note: you also need to set LOG=1 to enable logging, or use QUIET=1)",
         handler => sub {
             my ($go, $val, $r) = @_;
             $ENV{QUIET} = 1;
         },
         tags => ['category:logging'],
     },
 
 );
 
 sub __default_env_name {
     my ($prog) = @_;
 
     for ($prog) {
         $_ //= "PROG"; 
         $_ = uc($_);
         s/[^A-Z0-9]+/_/g;
     }
     "${prog}_OPT";
 }
 
 sub hook_before_run {}
 
 sub hook_before_read_config_file {}
 
 sub hook_after_read_config_file {}
 
 sub hook_before_action {}
 
 sub hook_after_action {}
 
 sub get_meta {
     my ($self, $r, $url) = @_;
 
     my $res = $self->riap_client->request(meta => $url);
     die $res unless $res->[0] == 200;
     my $meta = $res->[2];
     $r->{meta} = $meta;
     $log->tracef("[pericmd] Running hook_after_get_meta ...");
     $self->hook_after_get_meta($r);
     $meta;
 }
 
 sub get_program_and_subcommand_name {
     my ($self, $r) = @_;
     my $res = ($self->program_name // "") . " " .
         ($r->{subcommand_name} // "");
     $res =~ s/\s+$//;
     $res;
 }
 
 sub get_subcommand_data {
     my ($self, $name) = @_;
 
     my $scs = $self->subcommands;
     return undef unless $scs;
 
     if (ref($scs) eq 'CODE') {
         return $scs->($self, name=>$name);
     } else {
         return $scs->{$name};
     }
 }
 
 sub list_subcommands {
     my ($self) = @_;
     return $self->{_cache_subcommands} if $self->{_cache_subcommands};
 
     my $scs = $self->subcommands;
     my $res;
     if ($scs) {
         if (ref($scs) eq 'CODE') {
             $scs = $scs->($self);
             die [500, "BUG: Subcommands code didn't return a hashref"]
                 unless ref($scs) eq 'HASH';
         }
         $res = $scs;
     } else {
         $res = {};
     }
     $self->{_cache_subcommands} = $res;
     $res;
 }
 
 sub status2exitcode {
     my ($self, $status) = @_;
     return 0 if $status =~ /^2..|304/;
     $status - 300;
 }
 
 sub _detect_completion {
     my ($self, $r) = @_;
 
     if ($ENV{COMP_SHELL}) {
         $r->{shell} = $ENV{COMP_SHELL};
         return 1;
     } elsif ($ENV{COMP_LINE}) {
         $r->{shell} = 'bash';
         return 1;
     } elsif ($ENV{COMMAND_LINE}) {
         $r->{shell} = 'tcsh';
         return 1;
     }
 
     $r->{shell} //= 'bash';
     0;
 }
 
 sub _read_env {
     my ($self, $r) = @_;
 
     return [] unless $self->read_env;
     my $env_name = $self->env_name;
     my $env = $ENV{$env_name};
     $log->tracef("[pericmd] Checking env %s: %s", $env_name, $env);
     return [] unless defined $env;
 
 
     my $words;
     if ($r->{shell} eq 'bash') {
         require Complete::Bash;
         ($words, undef) = @{ Complete::Bash::parse_cmdline($env, 0) };
     } elsif ($r->{shell} eq 'fish') {
         require Complete::Fish;
         ($words, undef) = @{ Complete::Fish::parse_cmdline($env) };
     } elsif ($r->{shell} eq 'tcsh') {
         require Complete::Tcsh;
         ($words, undef) = @{ Complete::Tcsh::parse_cmdline($env) };
     } elsif ($r->{shell} eq 'zsh') {
         require Complete::Zsh;
         ($words, undef) = @{ Complete::Zsh::parse_cmdline($env) };
     } else {
         die "Unsupported shell '$r->{shell}'";
     }
     $log->tracef("[pericmd] Words from env: %s", $words);
     $words;
 }
 
 sub do_completion {
     my ($self, $r) = @_;
 
     local $r->{in_completion} = 1;
 
     my ($words, $cword);
     if ($r->{shell} eq 'bash') {
         require Complete::Bash;
         ($words, $cword) = @{ Complete::Bash::parse_cmdline() };
     } elsif ($r->{shell} eq 'fish') {
         require Complete::Fish;
         ($words, $cword) = @{ Complete::Fish::parse_cmdline() };
     } elsif ($r->{shell} eq 'tcsh') {
         require Complete::Tcsh;
         ($words, $cword) = @{ Complete::Tcsh::parse_cmdline() };
     } elsif ($r->{shell} eq 'zsh') {
         require Complete::Zsh;
         ($words, $cword) = @{ Complete::Zsh::parse_cmdline() };
     } else {
         die "Unsupported shell '$r->{shell}'";
     }
 
     shift @$words; $cword--; 
 
     @ARGV = @$words;
 
     $self->_parse_argv1($r);
 
     if ($r->{read_env}) {
         my $env_words = $self->_read_env($r);
         unshift @ARGV, @$env_words;
         $cword += @$env_words;
     }
 
 
     $r->{format} = 'text';
 
     my $scd = $r->{subcommand_data};
     my $meta = $self->get_meta($r, $scd->{url} // $self->{url});
 
     my $subcommand_name_from = $r->{subcommand_name_from} // '';
 
     require Perinci::Sub::Complete;
     my $compres = Perinci::Sub::Complete::complete_cli_arg(
         meta            => $meta, 
         words           => $words,
         cword           => $cword,
         common_opts     => $self->common_opts,
         riap_server_url => $scd->{url},
         riap_uri        => undef,
         riap_client     => $self->riap_client,
         extras          => {r=>$r, cmdline=>$self},
         func_arg_starts_at => ($subcommand_name_from eq 'arg' ? 1:0),
         completion      => sub {
             my %args = @_;
             my $type = $args{type};
 
             if ($self->completion) {
                 my $res = $self->completion(%args);
                 return $res if $res;
             }
             if ($self->subcommands &&
                     $subcommand_name_from ne '--cmd' &&
                          $type eq 'arg' && $args{argpos}==0) {
                 require Complete::Util;
                 return Complete::Util::complete_array_elem(
                     array => [keys %{ $self->list_subcommands }],
                     word  => $words->[$cword]);
             }
 
             return undef;
         },
     );
 
     my $formatted;
     if ($r->{shell} eq 'bash') {
         $formatted = Complete::Bash::format_completion(
             $compres, {word=>$words->[$cword]});
     } elsif ($r->{shell} eq 'fish') {
         $formatted = Complete::Fish::format_completion($compres);
     } elsif ($r->{shell} eq 'tcsh') {
         $formatted = Complete::Tcsh::format_completion($compres);
     } elsif ($r->{shell} eq 'zsh') {
         $formatted = Complete::Zsh::format_completion($compres);
     }
 
     [200, "OK", $formatted,
      {
          "func.words" => $words,
          "func.cword" => $cword,
          "cmdline.skip_format" => 1,
      }];
 }
 
 sub _read_config {
     require Perinci::CmdLine::Util::Config;
 
     my ($self, $r) = @_;
 
     $log->tracef("[pericmd] Finding config files ...");
     my $res = Perinci::CmdLine::Util::Config::read_config(
         config_paths    => $r->{config_paths},
         config_filename => $self->config_filename,
         config_dirs     => $self->config_dirs,
         program_name    => $self->program_name,
     );
     die $res unless $res->[0] == 200;
     $r->{config} = $res->[2];
     $r->{read_config_files} = $res->[3]{'func.read_files'};
     $log->tracef("[pericmd] Read config files: %s",
                  $r->{'read_config_files'});
 }
 
 sub __min(@) {
     my $m = $_[0];
     for (@_) {
         $m = $_ if $_ < $m;
     }
     $m;
 }
 
 sub __editdist {
     my @a = split //, shift;
     my @b = split //, shift;
 
     my @d;
     $d[$_][0] = $_ for 0 .. @a;
     $d[0][$_] = $_ for 0 .. @b;
 
     for my $i (1 .. @a) {
         for my $j (1 .. @b) {
             $d[$i][$j] = (
                 $a[$i-1] eq $b[$j-1]
                     ? $d[$i-1][$j-1]
                     : 1 + __min(
                         $d[$i-1][$j],
                         $d[$i][$j-1],
                         $d[$i-1][$j-1]
                     )
                 );
         }
     }
 
     $d[@a][@b];
 }
 
 sub __uniq {
     my %seen = ();
     my $k;
     my $seen_undef;
     grep { defined $_ ? not $seen{ $k = $_ }++ : not $seen_undef++ } @_;
 }
 
 sub __find_similar_strings {
     my ($needle, $haystack, $cut) = @_;
 
     my $factor   = 1.5;
     my $max_dist = 4;
 
     my @res =
         map { $_->[0] }
         sort { $a->[1] <=> $b->[1] }
         grep { defined }
         map {
             my $el = $_;
             if ($cut && length($_) > length($needle)) {
                 $el = substr($el, 0, length($needle));
             }
             my $d = __editdist($el, $needle);
             my $max_distance = __min(
                 __min(length($el), length($needle))/$factor,
                 $max_dist,
             );
             ($d <= $max_distance) ? [$_, $d] : undef
         } @$haystack;
 
     $cut ? __uniq(@res) : @res;
 }
 
 sub __find_similar_go_opts {
     my ($opt, $go_spec) = @_;
 
     $opt =~ s/^--?//;
 
     my @ospecs0 = ref($go_spec) eq 'ARRAY' ?
         keys(%{ { @$go_spec } }) : keys(%$go_spec);
     my @ospecs;
     for my $o (@ospecs0) {
         $o =~ s/^--?//;
         my $is_neg = $o =~ /\!$/;
         $o =~ s/[=:].+|[?+!]$//;
         for (split /\|/, $o) {
             if ($is_neg && length($_) > 1) {
                 push @ospecs, $_, "no$_", "no-$_";
             } else {
                 push @ospecs, $_;
             }
         }
     }
 
     map { length($_) > 1 ? "--$_" : "-$_" }
         __find_similar_strings($opt, \@ospecs, "cut");
 }
 
 sub _parse_argv1 {
     my ($self, $r) = @_;
 
     my @go_spec;
     {
 
         require Getopt::Long;
         my $old_go_conf = Getopt::Long::Configure(
             'pass_through', 'no_ignore_case', 'bundling', 'no_auto_abbrev');
         my $co = $self->common_opts // {};
         for my $k (keys %$co) {
             push @go_spec, $co->{$k}{getopt} => sub {
                 my ($go, $val) = @_;
                 $co->{$k}{handler}->($go, $val, $r);
             };
         }
         Getopt::Long::GetOptions(@go_spec);
         Getopt::Long::Configure($old_go_conf);
     }
 
     {
         my $scn = $r->{subcommand_name};
         my $scn_from = $r->{subcommand_name_from};
         if (!defined($scn) && defined($self->{default_subcommand})) {
             if ($self->get_subcommand_from_arg == 1) {
                 $scn = $self->{default_subcommand};
                 $scn_from = 'default_subcommand';
             } elsif ($self->get_subcommand_from_arg == 2 && !@ARGV) {
                 $scn = $self->{default_subcommand};
                 $scn_from = 'default_subcommand';
             }
         }
         if (!defined($scn) && $self->{subcommands} && @ARGV) {
             if ($ARGV[0] =~ /\A-/) {
                 if ($r->{in_completion}) {
                     $scn = shift @ARGV;
                     $scn_from = 'arg';
                 } else {
                     my $suggestion = '';
                     my @similar = __find_similar_go_opts($ARGV[0], \@go_spec);
                     $suggestion = " (perhaps you meant ".
                         join("/", @similar)."?)" if @similar;
                     die [400, "Unknown option: $ARGV[0]".$suggestion];
                 }
             } else {
                 $scn = shift @ARGV;
                 $scn_from = 'arg';
             }
         }
 
         my $scd;
         if (defined $scn) {
             $scd = $self->get_subcommand_data($scn);
             unless ($r->{in_completion}) {
                 unless ($scd) {
                     my $suggestion = '';
                     my $scs = $self->subcommands;
                     if (ref($scs) eq 'HASH') {
                         my @similar =
                             __find_similar_strings($scn, [keys %$scs]);
                         $suggestion = " (perhaps you meant ".
                             join("/", @similar)."?)" if @similar;
                     }
                     die [500, "Unknown subcommand: $scn".$suggestion];
                 }
             }
         } elsif (!$r->{action} && $self->{subcommands}) {
             $r->{action} = 'help';
             $r->{skip_parse_subcommand_argv} = 1;
         } else {
             $scn = '';
             $scd = {
                 url => $self->url,
                 summary => $self->summary,
                 description => $self->description,
                 pass_cmdline_object => $self->pass_cmdline_object,
                 tags => $self->tags,
             };
         }
         $r->{subcommand_name} = $scn;
         $r->{subcommand_name_from} = $scn_from;
         $r->{subcommand_data} = $scd;
     }
 
     $r->{dry_run} = 1 if $ENV{DRY_RUN};
 
     $r->{_parse_argv1_done} = 1;
 }
 
 sub _parse_argv2 {
     require Perinci::CmdLine::Util::Config;
 
     my ($self, $r) = @_;
 
     my %args;
 
     if ($r->{read_env}) {
         my $env_words = $self->_read_env($r);
         unshift @ARGV, @$env_words;
     }
 
     if ($r->{skip_parse_subcommand_argv}) {
         return [200, "OK (subcommand options parsing skipped)"];
     } else {
         my $scd = $r->{subcommand_data};
         my $meta = $self->get_meta($r, $scd->{url});
 
         if ($scd->{args}) {
             $args{$_} = $scd->{args}{$_} for keys %{ $scd->{args} };
         }
 
         if ($r->{read_config}) {
 
             $log->tracef("[pericmd] Running hook_before_read_config_file ...");
             $self->hook_before_read_config_file($r);
 
             $self->_read_config($r);
 
             $log->tracef("[pericmd] Running hook_after_read_config_file ...");
             $self->hook_after_read_config_file($r);
 
             my $res = Perinci::CmdLine::Util::Config::get_args_from_config(
                 r                  => $r,
                 config             => $r->{config},
                 args               => \%args,
                 subcommand_name    => $r->{subcommand_name},
                 config_profile     => $r->{config_profile},
                 common_opts        => $self->common_opts,
                 meta               => $meta,
                 meta_is_normalized => 1,
             );
             die $res unless $res->[0] == 200;
             $log->tracef("[pericmd] args after reading config files: %s",
                          \%args);
             my $found = $res->[3]{'func.found'};
             if (defined($r->{config_profile}) && !$found &&
                     defined($r->{read_config_files}) &&
                         @{$r->{read_config_files}} &&
                             !$r->{ignore_missing_config_profile_section}) {
                 return [412, "Profile '$r->{config_profile}' not found ".
                             "in configuration file"];
             }
 
         }
 
 
         my $copts = $self->common_opts;
         my %old_handlers;
         for (keys %$copts) {
             my $h = $copts->{$_}{handler};
             $copts->{$_}{handler} = sub {
                 my ($go, $val) = @_;
                 $h->($go, $val, $r);
             };
             $old_handlers{$_} = $h;
         }
 
         my $has_cmdline_src;
         for my $ak (keys %{$meta->{args} // {}}) {
             my $av = $meta->{args}{$ak};
             if ($av->{cmdline_src}) {
                 $has_cmdline_src = 1;
                 last;
             }
             if ($av->{stream}) {
                 unless ($av->{cmdline_src} &&
                             $av->{cmdline_src} =~
                                 /\A(stdin|file|stdin_or_files?)\z/) {
                     die "BUG: stream argument '$ak' needs to have cmdline_src ".
                         "set to stdin, file, stdin_or_file, or stdin_or_files";
                 }
             }
         }
 
         require Perinci::Sub::GetArgs::Argv;
         my $ga_res = Perinci::Sub::GetArgs::Argv::get_args_from_argv(
             argv                => \@ARGV,
             args                => \%args,
             meta                => $meta,
             meta_is_normalized  => 1,
             allow_extra_elems   => $has_cmdline_src ? 1:0,
             per_arg_json        => $self->{per_arg_json},
             per_arg_yaml        => $self->{per_arg_yaml},
             common_opts         => $copts,
             strict              => $r->{in_completion} ? 0:1,
             on_missing_required_args => sub {
                 my %a = @_;
 
                 my ($an, $aa, $as) = ($a{arg}, $a{args}, $a{spec});
                 my $src = $as->{cmdline_src};
                 if ($src && $as->{req}) {
                     return 1;
                 } else {
                     return 0;
                 }
             },
         );
 
         return $ga_res unless $ga_res->[0] == 200;
 
         require Perinci::Sub::CoerceArgs;
         my $coerce_res = Perinci::Sub::CoerceArgs::coerce_args(
             meta                => $meta,
             meta_is_normalized  => 1,
             args                => $ga_res->[2],
         );
 
         return $coerce_res unless $coerce_res->[0] == 200;
 
         for (keys %$copts) {
             $copts->{$_}{handler} = $old_handlers{$_};
         }
 
         return $ga_res;
     }
 }
 
 sub parse_argv {
     my ($self, $r) = @_;
 
     $log->tracef("[pericmd] Parsing \@ARGV: %s", \@ARGV);
 
 
     $self->_parse_argv1($r) unless $r->{_parse_argv1_done};
     $self->_parse_argv2($r);
 }
 
 sub __gen_iter {
     require Data::Sah::Util::Type;
 
     my ($fh, $sch, $argname) = @_;
     my $type = Data::Sah::Util::Type::get_type($sch);
 
     if (Data::Sah::Util::Type::is_simple($sch)) {
         return sub {
             local $/ = \(64*1024) if $type eq 'buf';
 
             state $eof;
             return undef if $eof;
             my $l = <$fh>;
             unless (defined $l) {
                 $eof++; return undef;
             }
             $l;
         };
     } else {
         require JSON;
         state $json = JSON->new->allow_nonref;
         my $i = -1;
         return sub {
             state $eof;
             return undef if $eof;
             $i++;
             my $l = <$fh>;
             unless (defined $l) {
                 $eof++; return undef;
             }
             eval { $l = $json->decode($l) };
             if ($@) {
                 die "Invalid JSON in stream argument '$argname' record #$i: $@";
             }
             $l;
         };
     }
 }
 
 sub parse_cmdline_src {
     my ($self, $r) = @_;
 
     my $action = $r->{action};
     my $meta   = $r->{meta};
 
     my $url = $r->{subcommand_data}{url} // $self->{url} // '';
     my $is_network = $url =~ m!^(https?|riap[^:]+):!;
 
     if ($action eq 'call') {
         my $args_p = $meta->{args} // {};
         my $stdin_seen;
         for my $an (sort {
             my $csa  = $args_p->{$a}{cmdline_src};
             my $csb  = $args_p->{$b}{cmdline_src};
             my $posa = $args_p->{$a}{pos} // 9999;
             my $posb = $args_p->{$b}{pos} // 9999;
 
             (
                 !$csa || !$csb ? 0 :
                     $csa eq 'stdin_line' && $csb eq 'stdin_line' ? 0 :
                     $csa eq 'stdin_line' && $csb =~ /^(stdin|stdin_or_files?)/ ? -1 :
                     $csb eq 'stdin_line' && $csa =~ /^(stdin|stdin_or_files?)/ ? 1 : 0
             )
             ||
 
             ($posa <=> $posb)
 
             ||
             ($a cmp $b)
         } keys %$args_p) {
             my $as = $args_p->{$an};
             my $src = $as->{cmdline_src};
             my $type = $as->{schema}[0]
                 or die "BUG: No schema is defined for arg '$an'";
             my $do_stream = $as->{stream} && $url !~ /^https?:/;
             if ($src) {
                 die [531,
                      "Invalid 'cmdline_src' value for argument '$an': $src"]
                     unless $src =~ /\A(stdin|file|stdin_or_files?|stdin_line)\z/;
                 die [531,
                      "Sorry, argument '$an' is set cmdline_src=$src, but type ".
                          "is not str/buf/array, only those are supported now"]
                     unless $do_stream || $type =~ /\A(str|buf|array)\z/;
                 if ($src =~ /\A(stdin|stdin_or_files?)\z/) {
                     die [531, "Only one argument can be specified ".
                              "cmdline_src stdin/stdin_or_file/stdin_or_files"]
                         if $stdin_seen++;
                 }
                 my $is_ary = $type eq 'array';
                 if ($src eq 'stdin_line' && !exists($r->{args}{$an})) {
                     require Perinci::Object;
                     my $term_readkey_available = eval { require Term::ReadKey; 1 };
                     my $prompt = Perinci::Object::rimeta($as)->langprop('cmdline_prompt') //
                         sprintf($self->default_prompt_template, $an);
                     print $prompt;
                     my $iactive = (-t STDOUT);
                     Term::ReadKey::ReadMode('noecho')
                           if $term_readkey_available && $iactive && $as->{is_password};
                     chomp($r->{args}{$an} = <STDIN>);
                     do { print "\n"; Term::ReadKey::ReadMode(0) if $term_readkey_available }
                         if $iactive && $as->{is_password};
                     $r->{args}{"-cmdline_src_$an"} = 'stdin_line';
                 } elsif ($src eq 'stdin' || $src eq 'file' &&
                         ($r->{args}{$an}//"") eq '-') {
                     die [400, "Argument $an must be set to '-' which means ".
                              "from stdin"]
                         if defined($r->{args}{$an}) &&
                             $r->{args}{$an} ne '-';
                     $r->{args}{$an} = $do_stream ?
                         __gen_iter(\*STDIN, $as->{schema}, $an) :
                             $is_ary ? [<STDIN>] :
                                 do {local $/; ~~<STDIN>};
                     $r->{args}{"-cmdline_src_$an"} = 'stdin';
                 } elsif ($src eq 'stdin_or_file' || $src eq 'stdin_or_files') {
                     local @ARGV = @ARGV;
                     unshift @ARGV, $r->{args}{$an}
                         if defined $r->{args}{$an};
 
                     splice @ARGV, 1
                         if @ARGV > 1 && $src eq 'stdin_or_file';
 
 
                     for (@ARGV) {
                         next if $_ eq '-';
                         die [500, "Can't read file '$_': $!"] if !(-r $_);
                     }
 
                     $r->{args}{"-cmdline_srcfilenames_$an"} = [@ARGV];
                     $r->{args}{$an} = $do_stream ?
                         __gen_iter(\*ARGV, $as->{schema}, $an) :
                             $is_ary ? [<>] :
                                 do {local $/; ~~<>};
                     $r->{args}{"-cmdline_src_$an"} = $src;
                 } elsif ($src eq 'file') {
                     unless (exists $r->{args}{$an}) {
                         if ($as->{req}) {
                             die [400,
                                  "Please specify filename for argument '$an'"];
                         } else {
                             next;
                         }
                     }
                     die [400, "Please specify filename for argument '$an'"]
                         unless defined $r->{args}{$an};
                     my $fh;
                     my $fname = $r->{args}{$an};
                     unless (open $fh, "<", $fname) {
                         die [500, "Can't open file '$fname' for argument '$an'".
                                  ": $!"];
                     }
                     $r->{args}{$an} = $do_stream ?
                         __gen_iter($fh, $as->{schema}, $an) :
                             $is_ary ? [<$fh>] :
                                 do { local $/; ~~<$fh> };
                     $r->{args}{"-cmdline_src_$an"} = 'file';
                     $r->{args}{"-cmdline_srcfilenames_$an"} = [$fname];
                 }
             }
 
             if ($self->riap_version == 1.2 && $is_network &&
                     defined($r->{args}{$an}) && $args_p->{$an}{schema} &&
                         $args_p->{$an}{schema}[0] eq 'buf' &&
                             !$r->{args}{"$an:base64"}) {
                 require MIME::Base64;
                 $r->{args}{"$an:base64"} =
                     MIME::Base64::encode_base64($r->{args}{$an}, "");
                 delete $r->{args}{$an};
             }
         } 
     }
 }
 
 sub select_output_handle {
     my ($self, $r) = @_;
 
     my $resmeta = $r->{res}[3] // {};
 
     my $handle;
     if ($resmeta->{"cmdline.page_result"}) {
         require File::Which;
         my $pager = $resmeta->{"cmdline.pager"} //
             $ENV{PAGER};
         unless (defined $pager) {
             $pager = "less -FRSX" if File::Which::which("less");
         }
         unless (defined $pager) {
             $pager = "more" if File::Which::which("more");
         }
         unless (defined $pager) {
             die [500, "Can't determine PAGER"];
         }
         last unless $pager; 
         open $handle, "| $pager";
     }
     $handle //= \*STDOUT;
     $r->{output_handle} = $handle;
 }
 
 sub display_result {
     require Data::Sah::Util::Type;
 
     my ($self, $r) = @_;
 
     my $meta = $r->{meta};
     my $res = $r->{res};
     my $fres = $r->{fres};
     my $resmeta = $res->[3] // {};
 
     my $handle = $r->{output_handle};
 
     my $sch = $meta->{result}{schema};
     my $type = Data::Sah::Util::Type::get_type($sch) // '';
 
     if ($resmeta->{stream} // $meta->{result}{stream}) {
         my $x = $res->[2];
         if (ref($x) eq 'CODE') {
             if (Data::Sah::Util::Type::is_simple($sch)) {
                 while (defined(my $l = $x->())) {
                     print $l;
                     print "\n" unless $type eq 'buf';
                 }
             } else {
                 require JSON;
                 state $json = JSON->new->allow_nonref;
                 while (defined(my $rec = $x->())) {
                     print $json->encode($rec), "\n";
                 }
             }
         } else {
             die [500, "Invalid stream in result (not a coderef)"];
         }
     } else {
         print $handle $fres;
     }
 }
 
 sub run {
     my ($self) = @_;
     $log->tracef("[pericmd] -> run(), \@ARGV=%s", \@ARGV);
 
     my $co = $self->common_opts;
 
     my $r = {
         orig_argv   => [@ARGV],
         common_opts => $co,
     };
 
     if ($self->_detect_completion($r)) {
         $r->{res} = $self->do_completion($r);
         goto FORMAT;
     }
 
     $r->{naked_res} = $co->{naked_res}{default} if $co->{naked_res};
     $r->{format}    = $co->{format}{default} if $co->{format};
 
     if ($self->read_config) {
         $r->{read_config} = 1;
     }
 
     if ($self->read_env) {
         $r->{read_env} = 1;
     }
 
     eval {
         $log->tracef("[pericmd] Running hook_before_run ...");
         $self->hook_before_run($r);
 
         my $parse_res = $self->parse_argv($r);
         if ($parse_res->[0] == 501) {
             $r->{send_argv} = 1;
         } elsif ($parse_res->[0] != 200) {
             die $parse_res;
         }
         $r->{parse_argv_res} = $parse_res;
         $r->{args} = $parse_res->[2] // {};
 
         $r->{action} //= 'call';
 
         $log->tracef("[pericmd] Running hook_after_parse_argv ...");
         $self->hook_after_parse_argv($r);
 
         $self->parse_cmdline_src($r);
 
 
         my $missing = $parse_res->[3]{"func.missing_args"};
         die [400, "Missing required argument(s): ".join(", ", @$missing)]
             if $missing && @$missing;
 
         my $scd = $r->{subcommand_data};
         if ($scd->{pass_cmdline_object} // $self->pass_cmdline_object) {
             $r->{args}{-cmdline} = $self;
             $r->{args}{-cmdline_r} = $r;
         }
 
         $log->tracef("[pericmd] Running hook_before_action ...");
         $self->hook_before_action($r);
 
         my $meth = "action_$r->{action}";
         die [500, "Unknown action $r->{action}"] unless $self->can($meth);
         $log->tracef("[pericmd] Running %s() ...", $meth);
         $r->{res} = $self->$meth($r);
 
         $log->tracef("[pericmd] Running hook_after_action ...");
         $self->hook_after_action($r);
     };
     my $err = $@;
     if ($err || !$r->{res}) {
         if ($err) {
             $err = [500, "Died: $err"] unless ref($err) eq 'ARRAY';
             if (%Devel::Confess::) {
                 require Scalar::Util;
                 my $id = Scalar::Util::refaddr($err);
                 my $stack_trace = $Devel::Confess::MESSAGES{$id};
                 $err->[1] .= "\n$stack_trace" if $stack_trace;
             }
             $err->[1] =~ s/\n+$//;
             $r->{res} = $err;
         } else {
             $r->{res} = [500, "Bug: no response produced"];
         }
     } elsif (ref($r->{res}) ne 'ARRAY') {
         $log->tracef("[pericmd] res=%s", $r->{res}); 
         $r->{res} = [500, "Bug in program: result not an array"];
     } elsif (!$r->{res}[0] || $r->{res}[0] < 200 || $r->{res}[0] > 555) {
         $log->tracef("[pericmd] res=%s", $r->{res}); 
         $r->{res} = [500, "Bug in program: invalid result status, ".
                          "must be 200 <= x <= 555"];
     }
     $r->{format} //= $r->{res}[3]{'cmdline.default_format'};
     $r->{format} //= $r->{meta}{'cmdline.default_format'};
     my $restore_orig_result;
     my $orig_result;
     if (exists $r->{res}[3]{'cmdline.result'}) {
         $restore_orig_result = 1;
         $orig_result = $r->{res}[2];
         $r->{res}[2] = $r->{res}[3]{'cmdline.result'};
     }
   FORMAT:
     if ($self->skip_format ||
             $r->{meta}{'cmdline.skip_format'} ||
             $r->{res}[3]{'cmdline.skip_format'}) {
         if (!($r->{res}[0] =~ /\A2/ || $r->{res}[0] == 304) &&
                 !defined($r->{res}[2])) {
             $r->{fres} = "ERROR $r->{res}[0]: $r->{res}[1]" .
                 ($r->{res}[1] =~ /\R\z/ ? "" : "\n");
         } else {
             $r->{fres} = $r->{res}[2] // '';
         }
     } elsif ($r->{res}[3]{stream} // $r->{meta}{result}{stream}) {
     } else {
         $log->tracef("[pericmd] Running hook_format_result ...");
         $r->{fres} = $self->hook_format_result($r) // '';
     }
     $self->select_output_handle($r);
     $log->tracef("[pericmd] Running hook_display_result ...");
     $self->hook_display_result($r);
     $log->tracef("[pericmd] Running hook_after_run ...");
     $self->hook_after_run($r);
 
     if ($restore_orig_result) {
         $r->{res}[2] = $orig_result;
     }
 
     my $exitcode;
     if ($r->{res}[3] && defined($r->{res}[3]{'cmdline.exit_code'})) {
         $exitcode = $r->{res}[3]{'cmdline.exit_code'};
     } else {
         $exitcode = $self->status2exitcode($r->{res}[0]);
     }
     if ($self->exit) {
         $log->tracef("[pericmd] exit(%s)", $exitcode);
         exit $exitcode;
     } else {
         $log->tracef("[pericmd] <- run(), exitcode=%s", $exitcode);
         $r->{res}[3]{'x.perinci.cmdline.base.exit_code'} = $exitcode;
         return $r->{res};
     }
 }
 
 1;
 
 __END__
 
### Perinci/CmdLine/Classic.pm ###
 package Perinci::CmdLine::Classic;
 
 our $DATE = '2015-10-20'; 
 our $VERSION = '1.60'; 
 
 use 5.010001;
 use Log::Any::IfLOG '$log';
 
 use Moo;
 use experimental 'smartmatch'; 
 use Locale::TextDomain::UTF8 'Perinci-CmdLine-Classic';
 use Perinci::Object;
 use Scalar::Util qw(blessed);
 
 our $REQ_VERSION = 0; 
 
 extends 'Perinci::CmdLine::Base';
 
 with 'Color::Theme::Role::ANSI' unless $ENV{COMP_LINE};
 with 'Perinci::CmdLine::Classic::Role::Help' unless $ENV{COMP_LINE};
 with 'Term::App::Role::Attrs' unless $ENV{COMP_LINE};
 
 has log => (is => 'rw', default=>sub{1});
 has undo => (is=>'rw', default=>sub{0});
 has undo_dir => (
     is => 'rw',
     lazy => 1,
     default => sub {
         require File::HomeDir;
 
         my $self = shift;
         my $dir = File::HomeDir->my_home . "/." . $self->program_name;
         mkdir $dir unless -d $dir;
         $dir .= "/.undo";
         mkdir $dir unless -d $dir;
         $dir;
     }
 );
 has riap_client => (
     is => 'rw',
     lazy => 1,
     default => sub {
         my $self = shift;
 
         require Perinci::Access;
         require Perinci::Access::Perl;
         require Perinci::Access::Schemeless;
         my %args = (
             riap_version => $self->riap_version,
             %{$self->riap_client_args // {}},
         );
         my %opts;
         if ($self->undo) {
             $opts{use_tx} = 1;
             $opts{custom_tx_manager} = sub {
                 my $pa = shift;
                 require Perinci::Tx::Manager;
                 state $txm = Perinci::Tx::Manager->new(
                     data_dir => $self->undo_dir,
                     pa => $pa,
                 );
                 $txm;
            };
         }
         $args{handlers} = {
             pl => Perinci::Access::Perl->new(%opts),
             '' => Perinci::Access::Schemeless->new(%opts),
         };
         Perinci::Access->new(%args);
     }
 );
 has action_metadata => (
     is => 'rw',
     default => sub {
         +{
             clear_history => {
             },
             help => {
                 default_log => 0,
                 use_utf8 => 1,
             },
             history => {
             },
             subcommands => {
                 default_log => 0,
                 use_utf8 => 1,
             },
             redo => {
             },
             call => {
             },
             undo => {
             },
             version => {
                 default_log => 0,
                 use_utf8 => 1,
             },
         },
     },
 );
 has default_prompt_template => (is=>'rw');
 
 sub log_any_app { goto \&log }
 
 sub VERSION {
     my ($pkg, $req) = @_;
     $REQ_VERSION = $req;
 }
 
 sub BUILD {
     my ($self, $args) = @_;
 
     my $formats = [qw(
                          text text-simple text-pretty
                          json json-pretty yaml perl
                          ruby phpserialization)];
 
     if (!$self->{default_prompt_template}) {
         $self->{default_prompt_template} = N__("Enter %s:") . " ",
     }
 
     if (!$self->{actions}) {
         $self->{actions} = {
             version => {
                 default_log => 0,
                 use_utf8 => 1,
             },
             help => {
                 default_log => 0,
                 use_utf8 => 1,
             },
             subcommands => {
                 default_log => 0,
                 use_utf8 => 1,
             },
             call => {},
 
             history => {},
             clear_history => {},
             redo => {},
             undo => {},
         };
     }
 
     my $_t = sub {
         no warnings;
         my $co_name = shift;
         my $copt = $Perinci::CmdLine::Base::copts{$co_name};
         my %res;
         for (keys %$copt) {
             if ($_ eq 'summary' || $_ eq 'usage') {
                 $res{$_} = N__($copt->{$_});
             } else {
                 $res{$_} = $copt->{$_};
             }
         }
         %res;
     };
 
     if (!$self->{common_opts}) {
         my $copts = {};
 
         $copts->{version} = {
             $_t->('version'),
             show_in_options => sub { $ENV{VERBOSE} },
         };
         $copts->{help} = {
             $_t->('help'),
             show_in_options => sub { $ENV{VERBOSE} },
         };
 
         unless ($self->skip_format) {
             $copts->{format} = {
                 $_t->('format'),
                 schema => ['str*' => in => $formats],
             };
             $copts->{json} = {
                 $_t->('json'),
                 summary => N__("Equivalent to --format=json-pretty"),
             };
             $copts->{naked_res} = {
                 $_t->('naked_res'),
                 summary => N__("When outputing as JSON, strip result envelope"),
             };
             $copts->{format_options} = {
                 getopt  => "format-options=s",
                 summary => N__("Pass options to formatter"),
                 handler => sub {
                     my ($go, $val, $r) = @_;
                     $r->{format_options} = __json_decode($val);
                 },
                 is_settable_via_config => 1,
                 tags => ['category:output'],
             };
         }
 
         if ($self->subcommands) {
             $copts->{subcommands} = {
                 $_t->('subcommands'),
                 show_in_options => sub {
                     my ($self, $r) = @_;
                     $ENV{VERBOSE} && !$r->{subcommand_name};
                 },
                 show_in_help => 0,
             };
         }
 
         if (defined $self->default_subcommand) {
             $copts->{cmd} = { $_t->('cmd') };
         }
 
         if ($self->read_config) {
             $copts->{config_path}    = { $_t->('config_path') };
             $copts->{no_config}      = { $_t->('no_config') };
             $copts->{config_profile} = { $_t->('config_profile') };
         }
 
         if ($self->read_env) {
             $copts->{no_env} = { $_t->('no_env') };
         }
 
         if ($self->log) {
             $copts->{log_level} = { $_t->('log_level'), };
             $copts->{trace}     = { $_t->('trace'), };
             $copts->{debug}     = { $_t->('debug'), };
             $copts->{verbose}   = { $_t->('verbose'), };
             $copts->{quiet}     = { $_t->('quiet'), };
         }
 
         if ($self->undo) {
             $copts->{history} = {
                 getopt  => 'history',
                 summary => N__('List actions history'),
                 handler => sub {
                     my ($go, $val, $r) = @_;
                     $r->{action} = 'history';
                     $r->{skip_parse_subcommand_argv} = 1;
                 },
                 tags => ['category:undo'],
             };
             $copts->{clear_history} = {
                 getopt  => "clear-history",
                 summary => N__('Clear actions history'),
                 handler => sub {
                     my ($go, $val, $r) = @_;
                     $r->{action} = 'clear_history';
                     $r->{skip_parse_subcommand_argv} = 1;
                 },
                 tags => ['category:undo'],
             };
             $copts->{undo} = {
                 getopt  => 'undo',
                 summary => N__('Undo previous action'),
                 handler => sub {
                     my ($go, $val, $r) = @_;
                     $r->{action} = 'undo';
                     $r->{skip_parse_subcommand_argv} = 1;
                 },
                 tags => ['category:undo'],
             };
             $copts->{redo} = {
                 getopt  => 'redo',
                 summary => N__('Redo previous undone action'),
                 handler => sub {
                     my ($go, $val, $r) = @_;
                     $r->{action} = 'redo';
                     $r->{skip_parse_subcommand_argv} = 1;
                 },
             };
         }
         $self->{common_opts} = $copts;
     }
 
     $self->{formats} //= $formats;
     $self->{per_arg_json} //= 1;
     $self->{per_arg_yaml} //= 1;
 
     unless ($ENV{COMP_LINE}) {
         my $ct = $self->{color_theme} // $ENV{PERINCI_CMDLINE_COLOR_THEME};
         if (!$ct) {
             if ($self->use_color) {
                 my $bg = $self->detect_terminal->{default_bgcolor} // '';
                 $ct = 'Default::default' .
                     ($bg eq 'ffffff' ? '_whitebg' : '');
             } else {
                 $ct = 'Default::no_color';
             }
         }
         $self->color_theme($ct);
     }
 }
 
 sub __json_decode {
     require JSON;
     state $json = do { JSON->new->allow_nonref };
     $json->decode(shift);
 }
 
 sub __json_encode {
     require JSON;
     state $json = do { JSON->new->allow_nonref };
     $json->encode(shift);
 }
 
 sub _color {
     my ($self, $color_name, $text) = @_;
     my $color_code = $color_name ?
         $self->get_theme_color_as_ansi($color_name) : "";
     my $reset_code = $color_code ? "\e[0m" : "";
     "$color_code$text$reset_code";
 }
 
 
 sub hook_format_row {
     state $dfpc = do {
         require Data::Format::Pretty::Console;
         Data::Format::Pretty::Console->new({interactive=>0});
     };
 
     my ($self, $r, $row) = @_;
     my $ref = ref($row);
     if (!$ref) {
         return ($row // "") . "\n";
     } elsif ($ref eq 'ARRAY' && !(grep {ref($_)} @$row)) {
         return join("\t", map { $dfpc->_format_cell($_) } @$row) . "\n";
     } else {
         return $dfpc->_format($row);
     }
 }
 
 sub hook_after_get_meta {
     my ($self, $r) = @_;
 
     if (risub($r->{meta})->can_dry_run) {
         $self->common_opts->{dry_run} = {
             getopt  => 'dry-run',
             summary => N__("Run in simulation mode (also via DRY_RUN=1)"),
             handler => sub {
                 my ($go, $val, $r) = @_;
                 $r->{dry_run} = 1;
                 $ENV{VERBOSE} = 1;
             },
         };
     }
 }
 
 my ($ph1, $ph2); 
 my $setup_progress;
 sub _setup_progress_output {
     my $self = shift;
 
     if ($ENV{PROGRESS} // (-t STDOUT)) {
         require Progress::Any::Output;
         my $out = Progress::Any::Output->set("TermProgressBarColor");
         $setup_progress = 1;
         require Monkey::Patch::Action;
         $ph1 = Monkey::Patch::Action::patch_package(
             'Log::Log4perl::Appender::Screen', 'log',
             'replace', sub {
                 my ($self, %params) = @_;
 
                 my $msg = $params{message};
                 $msg =~ s/\n//g;
 
                 if ($out->{lastlen}) {
                     print
                         "\b" x $out->{lastlen},
                             " " x $out->{lastlen},
                                 "\b" x $out->{lastlen};
                     undef $out->{lastlen};
                 }
 
                 $Progress::Any::output_data{"$out"}{force_update} = 1;
 
                 say $msg;
             },
         ) if defined &{"Log::Log4perl::Appender::Screen::log"};
         $ph2 = Monkey::Patch::Action::patch_package(
             'Log::Log4perl::Appender::ScreenColoredLevels', 'log',
             'replace', sub {
                 my ($self, %params) = @_;
                 my $msg = $params{message};
                 $msg =~ s/\n//g;
                 if (my $color=$self->{color}->{$params{log4p_level}}) {
                     $msg = Term::ANSIColor::colored($msg, $color);
                 }
 
                 if ($out->{lastlen}) {
                     print
                         "\b" x $out->{lastlen},
                             " " x $out->{lastlen},
                                 "\b" x $out->{lastlen};
                     undef $out->{lastlen};
                 }
 
                 $Progress::Any::output_data{"$out"}{force_update} = 1;
 
 
                 say $msg;
             }
         ) if defined &{"Log::Log4perl::Appender::ScreenColoredLevels::log"};
     }
 }
 
 sub _unsetup_progress_output {
     my $self = shift;
 
     return unless $setup_progress;
     my $out = $Progress::Any::outputs{''}[0];
     $out->cleanup if $out->can("cleanup");
     undef $ph1;
     undef $ph2;
     $setup_progress = 0;
 }
 
 sub _load_log_any_app {
     my ($self, $r) = @_;
     return if $r->{_log_any_app_loaded}++;
     require Log::Any::App;
     Log::Any::App::init();
 
     $log->debugf("Program %s started with arguments: %s",
                  $0, $r->{orig_argv});
 }
 
 sub hook_before_run {
     my ($self, $r) = @_;
 
     $log->tracef("Start of CLI run");
 
     $r->{orig_argv} = [@ARGV];
 }
 
 sub hook_after_parse_argv {
     my ($self, $r) = @_;
 
     unless ($ENV{COMP_LINE}) {
         my $do_log = $r->{subcommand_data}{log} //
             $r->{subcommand_data}{log_any_app} 
                 if $r->{subcommand_data};
         $do_log //= $ENV{LOG};
         $do_log //= $self->action_metadata->{$r->{action}}{default_log}
             if $self->{action};
         $do_log //= $self->log;
         $self->_load_log_any_app($r) if $do_log;
     }
 }
 
 sub hook_format_result {
     return if $ENV{COMP_LINE};
 
     my ($self, $r) = @_;
 
     my $res    = $r->{res};
     my $format = $r->{format} // 'text';
     my $meta   = $r->{meta};
 
     require Perinci::Result::Format;
 
     unless ($format ~~ @{ $self->formats }) {
         warn "Unknown output format '$format'";
         $format = 'text';
     }
 
     $res->[3]{format_options} = $r->{format_options} if $r->{format_options};
 
     my $fres;
     if ($res->[3]{is_stream}) {
         $log->tracef("Result is a stream");
         return undef;
     } elsif ($res->[3]{'x.hint.result_binary'} && $format =~ /text/) {
         $fres = $res->[2];
     } else {
         $log->tracef("Formatting output with %s", $format);
         $fres = Perinci::Result::Format::format($res, $format, $r->{naked_res});
     }
 
     if ($format=~/text/ && $r->{res}[0] =~ /\A[45]/ && defined($r->{res}[1])) {
         $fres = "$self->{program_name}: $fres";
     }
 
     $fres;
 }
 
 sub hook_display_result {
     my ($self, $r) = @_;
 
     my $res  = $r->{res};
     my $fres = $r->{fres};
     my $resmeta = $res->[3] // {};
 
     my $handle = $r->{output_handle};
 
     my $utf8;
     {
         last if defined($utf8 = $ENV{UTF8});
         if ($resmeta->{'x.hint.result_binary'}) {
             $utf8 = 0; last;
         }
         my $am = $self->action_metadata->{$r->{action}}
             if $r->{action};
         last if defined($utf8 //= $am->{use_utf8});
 
         if ($r->{subcommand_data}) {
             last if defined($utf8 //= $r->{subcommand_data}{use_utf8});
         }
 
         $utf8 //= $self->use_utf8
             if $self->can("use_utf8");
     }
     binmode(STDOUT, ":utf8") if $utf8;
 
     if ($ENV{COMP_LINE} || $res->[3]{"cmdline.skip_format"}) {
         print $handle $res->[2];
         return;
     }
 
     $self->display_result($r);
 }
 
 sub hook_after_run {
     my ($self, $r) = @_;
     $self->_unsetup_progress_output;
 }
 
 sub action_subcommands {
     my ($self, $r) = @_;
 
     if (!$self->subcommands) {
         return [200, "OK", __("There are no subcommands") . ".",
                 {"cmdline.skip_format"=>1}];
     }
 
     $r->{_help_buf} = '';
 
     my $subcommands = $self->list_subcommands;
 
 
     my %percat_subc; 
     while (my ($scn, $sc) = each %$subcommands) {
         my $cat = "";
         for my $tag (@{$sc->{tags} // []}) {
             my $tn = ref($tag) ? $tag->{name} : $tag;
             next unless $tn =~ /^category:(.+)/;
             $cat = $1;
             last;
         }
         $percat_subc{$cat}       //= {};
         $percat_subc{$cat}{$scn}   = $sc;
     }
     my $has_many_cats = scalar(keys %percat_subc) > 1;
 
     my $i = 0;
     for my $cat (sort keys %percat_subc) {
         if ($has_many_cats) {
             $self->_help_add_heading(
                 $r,
                 __x("{category} subcommands",
                     category => ucfirst($cat || __("main"))));
         }
         my $subc = $percat_subc{$cat};
         for my $scn (sort keys %$subc) {
             my $sc = $subc->{$scn};
             my $summary = rimeta($sc)->langprop("summary");
             $self->_help_add_row(
                 $r,
                 [$self->_color('program_name', $scn), $summary],
                 {column_widths=>[-17, -40], indent=>1});
         }
     }
     $self->_help_draw_curtbl($r);
 
     [200, "OK", $r->{_help_buf},
      {"cmdline.skip_format"=>1}];
 }
 
 sub action_version {
     no strict 'refs';
 
     my ($self, $r) = @_;
 
     my $url = $r->{subcommand_data}{url} // $self->url;
 
     my @text;
 
     {
         my $meta = $self->get_meta($r, $url);
         push @text, __x(
             "{program} version {version}",
             program => $self->_color('program_name',
                                      $self->get_program_and_subcommand_name),
             version => $self->_color('emphasis', ($meta->{entity_v} // "?")),
         ),
             ($meta->{entity_date} ? " ($meta->{entity_date})" : ""),
             "\n";
         for my $mod (@{ $meta->{'x.dynamic_generator_modules'} // [] }) {
             push @text, "  ", __x(
                 "{program} version {version}",
                 program => $self->_color('emphasis', $mod),
                 version => $self->_color('emphasis', (${"$mod\::VERSION"} // "?")),
             ),
                 (${"$mod\::DATE"} ? " (".${"$mod\::DATE"}.")" : ""),
                     "\n";
         }
     }
 
     for my $url (@{ $self->extra_urls_for_version // [] }) {
         my $meta = $self->get_meta($r, $url);
         push @text, "  ", __x(
             "{program} version {version}",
             program => $self->_color('emphasis', $url),
             version => $self->_color('emphasis', ($meta->{entity_v} // "?")),
         ),
             ($meta->{entity_date} ? " ($meta->{entity_date})" : ''),
             "\n";
     }
 
     push @text, "  ", __x(
         "{program} version {version}",
         program => $self->_color('emphasis', "Perinci::CmdLine::Classic"),
         version => $self->_color('emphasis',
                                  $Perinci::CmdLine::Classic::VERSION || "dev"),
     ),
         ($Perinci::CmdLine::Classic::DATE ? " ($Perinci::CmdLine::Classic::DATE)" : ""),
         "\n";
 
     [200, "OK", join("", @text), {"cmdline.skip_format"=>1}];
 }
 
 sub action_call {
     my ($self, $r) = @_;
 
     my $scn = $r->{subcommand_name};
     my $scd = $r->{subcommand_data};
 
     my %fargs = %{$r->{args} // {}};
 
     my $tx_id;
 
     my $dry_run = $r->{dry_run};
     my $using_tx = !$dry_run && $self->undo && ($scd->{undo} // 1);
 
     if ($r->{send_argv} && ($dry_run || $using_tx)) {
         return $r->{parse_argv_res};
     }
 
     if ($using_tx) {
         require UUID::Random;
         $tx_id = UUID::Random::generate();
         $tx_id =~ s/-.+//; 
         my $summary = join(" ", @{ $r->{orig_argv} });
         my $tres = $self->riap_client->request(
             begin_tx => "/", {tx_id=>$tx_id, summary=>$summary});
         if ($tres->[0] != 200) {
             return [$tres->[0], "Can't start transaction '$tx_id': $tres->[1]"];
         }
     }
 
     if ($r->{meta}{features}{progress}) {
         $self->_setup_progress_output;
     }
 
     my $res;
     if ($r->{send_argv}) {
         $res = $self->riap_client->request(
             call => $scd->{url},
             {argv=>$r->{orig_argv}}, 
         );
     } else {
         $res = $self->riap_client->request(
             call => $scd->{url},
             {args=>\%fargs, tx_id=>$tx_id, dry_run=>$dry_run});
     }
     $log->tracef("call res=%s", $res);
 
     if ($using_tx && $res->[0] =~ /\A(?:200|304)\z/) {
         my $tres = $self->riap_client->request(commit_tx => "/", {tx_id=>$tx_id});
         if ($tres->[0] != 200) {
             return [$tres->[0],"Can't commit transaction '$tx_id': $tres->[1]"];
         }
     }
 
     $res;
 }
 
 sub action_history {
     my ($self, $r) = @_;
     my $res = $self->riap_client->request(list_txs => "/", {detail=>1});
     $log->tracef("list_txs res=%s", $res);
     return $res unless $res->[0] == 200;
     $res->[2] = [sort {($b->{tx_commit_time}//0) <=> ($a->{tx_commit_time}//0)}
                      @{$res->[2]}];
     my @txs;
     for my $tx (@{$res->[2]}) {
         next unless $tx->{tx_status} =~ /[CUX]/;
         push @txs, {
             id          => $tx->{tx_id},
             start_time  => $tx->{tx_start_time},
             commit_time => $tx->{tx_commit_time},
             status      => $tx->{tx_status} eq 'X' ? 'error' :
                 $tx->{tx_status} eq 'U' ? 'undone' : '',
             summary     => $tx->{tx_summary},
         };
     }
     [200, "OK", \@txs];
 }
 
 sub action_clear_history {
     my ($self, $r) = @_;
     $self->riap_client->request(discard_all_txs => "/");
 }
 
 sub action_undo {
     my ($self, $r) = @_;
     $self->riap_client->request(undo => "/");
 }
 
 sub action_redo {
     my ($self, $r) = @_;
     $self->riap_client->request(redo => "/");
 }
 
 1;
 
 __END__
 
### Perinci/CmdLine/Classic/ColorTheme/Default.pm ###
 package Perinci::CmdLine::Classic::ColorTheme::Default;
 
 our $DATE = '2015-10-20'; 
 our $VERSION = '1.60'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 our %color_themes = (
 
     no_color => {
         v => 1.1,
         summary => 'Special theme that means no color',
         colors => {
         },
         no_color => 1,
     },
 
     default => {
         v => 1.1,
         summary => 'Default (for terminals with black background)',
         colors => {
             heading       => 'ff9933',
             text          => undef,
             error_label   => 'cc0000',
             warning_label => 'cccc00',
             program_name  => {ansi_fg=>"\e[1m"}, 
             option_name   => 'cc6633',
             emphasis      => {ansi_fg=>"\e[1m"}, 
         },
     },
 
     default_whitebg => {
         v => 1.1,
         summary => 'Default (for terminals with white background)',
         colors => {
         },
     },
 
 );
 
 1;
 
 __END__
 
### Perinci/CmdLine/Classic/Role/Help.pm ###
 package Perinci::CmdLine::Classic::Role::Help;
 
 our $DATE = '2015-10-20'; 
 our $VERSION = '1.60'; 
 
 
 use 5.010;
 use Moo::Role;
 
 use Locale::TextDomain::UTF8 'Perinci-CmdLine';
 use Perinci::Object;
 
 sub _help_draw_curtbl {
     my ($self, $r) = @_;
 
     if ($r->{_help_curtbl}) {
         $r->{_help_buf} .= $r->{_help_curtbl}->draw;
         undef $r->{_help_curtbl};
     }
 }
 
 sub _help_add_table {
     require Text::ANSITable;
 
     my ($self, $r, %args) = @_;
     my $columns = $args{columns} // 1;
 
     $self->_help_draw_curtbl($r);
     my $t = Text::ANSITable->new;
     $t->border_style('Default::spacei_ascii');
     $t->cell_pad(0);
     if ($args{column_widths}) {
         for (0..$columns-1) {
             $t->set_column_style($_, width => $args{column_widths}[$_]);
         }
     } else {
         my $tw = $self->term_width;
         my $cw = int($tw/$columns)-1;
         $t->cell_width($cw);
     }
     $t->show_header(0);
     $t->column_wrap(0); 
     $t->columns([0..$columns-1]);
 
     $r->{_help_curtbl} = $t;
 }
 
 sub _help_add_row {
     my ($self, $r, $row, $args) = @_;
     $args //= {};
     my $wrap    = $args->{wrap}   // 0;
     my $indent  = $args->{indent} // 0;
     my $columns = @$row;
 
     $self->_help_add_table(
         $r,
         columns=>$columns, column_widths=>$args->{column_widths})
         if !$r->{_help_curtbl} ||
             $columns != @{ $r->{_help_curtbl}{columns} };
 
     my $t = $r->{_help_curtbl};
     my $rownum = @{ $t->{rows} };
 
     $t->add_row($row);
 
     my $dux_available = eval { require Data::Unixish; 1 } && !$@;
 
     if ($dux_available) {
         for (0..@{$t->{columns}}-1) {
             my %styles = (formats=>[]);
             push @{ $styles{formats} },
                 [wrap=>{ansi=>1, mb=>1, width=>$t->{cell_width}-$indent*2}]
                 if $wrap;
             push @{ $styles{formats} }, [lins=>{text=>"  " x $indent}]
                 if $indent && $_ == 0;
             $t->set_cell_style($rownum, $_, \%styles);
         }
     }
 }
 
 sub _help_add_heading {
     my ($self, $r, $heading) = @_;
     $self->_help_add_row($r, [$self->_color('heading', $heading)]);
 }
 
 sub _color {
     my ($self, $color_name, $text) = @_;
     my $color_code = $color_name ?
         $self->get_theme_color_as_ansi($color_name) : "";
     my $reset_code = $color_code ? "\e[0m" : "";
     "$color_code$text$reset_code";
 }
 
 sub help_section_summary {
     my ($self, $r) = @_;
 
     my $summary = rimeta($r->{_help_meta})->langprop("summary");
     return unless $summary;
 
     my $name = $self->get_program_and_subcommand_name($r);
     my $ct = join(
         "",
         $self->_color('program_name', $name),
         ($name && $summary ? ' - ' : ''),
         $summary // "",
     );
     $self->_help_add_row($r, [$ct], {wrap=>1});
 }
 
 sub help_section_usage {
     my ($self, $r) = @_;
 
     my $co = $self->common_opts;
     my @con = grep {
         my $cov = $co->{$_};
         my $show = $cov->{show_in_usage} // 1;
         for ($show) { if (ref($_) eq 'CODE') { $_ = $_->($self, $r) } }
         $show;
     } sort {
         ($co->{$a}{order}//1) <=> ($co->{$b}{order}//1) || $a cmp $b
     } keys %$co;
 
     my $pn = $self->_color(
         'program_name', $self->get_program_and_subcommand_name($r));
     my $ct = "";
     for my $con (@con) {
         my $cov = $co->{$con};
         next unless $cov->{usage};
         $ct .= ($ct ? "\n" : "") . $pn . " " . __($cov->{usage});
     }
     if ($self->subcommands && !$r->{subcommand_name}) {
         if (defined $self->default_subcommand) {
             $ct .= ($ct ? "\n" : "") . $pn .
                 " " . __("--cmd=<other-subcommand> [options]");
         } else {
             $ct .= ($ct ? "\n" : "") . $pn .
                 " " . __("<subcommand> [options]");
         }
     } else {
         my $usage = $r->{_help_clidocdata}{usage_line};
         $usage =~ s/\[\[prog\]\]/$pn/;
         $usage =~ s/\[options\]/__("[options]")/e;
         $ct .= ($ct ? "\n" : "") . $usage;
     }
     $self->_help_add_heading($r, __("Usage"));
     $self->_help_add_row($r, [$ct], {indent=>1});
 }
 
 sub help_section_options {
     my ($self, $r) = @_;
 
     my $opts = $r->{_help_clidocdata}{opts};
     return unless keys %$opts;
 
     my $verbose = $r->{_help_verbose};
     my $info = $r->{_help_info};
     my $meta = $r->{_help_meta};
     my $args_p = $meta->{args};
     my $sc = $self->subcommands;
 
     my %cats; 
 
     for (keys %$opts) {
         push @{ $cats{$opts->{$_}{raw_category} // ''} }, $_;
     }
 
     for my $cat (sort keys %cats) {
         my @opts = sort {length($b)<=>length($a)} @{ $cats{$cat} };
         my $len = length($opts[0]);
         @opts = sort {
             (my $a_without_dash = $a) =~ s/^-+//;
             (my $b_without_dash = $b) =~ s/^-+//;
             lc($a) cmp lc($b);
         } @opts;
 
         my $cat_title;
         if ($cat eq '') {
             $cat_title = __("Options");
         } else {
             $cat_title = __x("{category} options", category=>ucfirst($cat));
         }
         $self->_help_add_heading($r, $cat_title);
 
         if ($verbose) {
             for my $opt_name (@opts) {
                 my $opt_spec = $opts->{$opt_name};
                 my $arg_spec = $opt_spec->{arg_spec};
                 my $ct = $self->_color('option_name', $opt_name);
                 if ($arg_spec && !$opt_spec->{main_opt} &&
                         defined($arg_spec->{pos})) {
                     if ($arg_spec->{greedy}) {
                         $ct .= " (=arg[$arg_spec->{pos}-])";
                     } else {
                         $ct .= " (=arg[$arg_spec->{pos}])";
                     }
                 }
                 if ($arg_spec && !$opt_spec->{main_opt} &&
                         defined($arg_spec->{cmdline_src})) {
                     $ct .= " (or from $arg_spec->{cmdline_src})";
                     $ct =~ s!_or_!/!;
                 }
                 $self->_help_add_row($r, [$ct], {indent=>1});
 
                 if ($opt_spec->{summary} || $opt_spec->{description}) {
                     my $ct = "";
                     $ct .= ($ct ? "\n\n":"")."$opt_spec->{summary}."
                         if $opt_spec->{summary};
                     $ct .= ($ct ? "\n\n":"").$opt_spec->{description}
                         if $opt_spec->{description};
                     $self->_help_add_row($r, [$ct], {indent=>2, wrap=>1});
                 }
             }
         } else {
             my $tw = $self->term_width;
             my $columns = int($tw/40); $columns = 1 if $columns < 1;
             while (1) {
                 my @row;
                 for (1..$columns) {
                     last unless @opts;
                     my $opt_name = shift @opts;
                     my $opt_spec = $opts->{$opt_name};
                     my $arg_spec = $opt_spec->{arg_spec};
                     my $ct = $self->_color('option_name', $opt_name);
                     if ($arg_spec && !$opt_spec->{main_opt} &&
                             defined($arg_spec->{pos})) {
                         if ($arg_spec->{greedy}) {
                             $ct .= " (=arg[$arg_spec->{pos}-])";
                         } else {
                             $ct .= " (=arg[$arg_spec->{pos}])";
                         }
                     }
                     if ($arg_spec && !$opt_spec->{main_opt} &&
                             defined($arg_spec->{cmdline_src})) {
                         $ct .= " (or from $arg_spec->{cmdline_src})";
                         $ct =~ s!_or_!/!;
                     }
                     push @row, $ct;
                 }
                 last unless @row;
                 for (@row+1 .. $columns) { push @row, "" }
                 $self->_help_add_row($r, \@row, {indent=>1});
             }
         }
     }
 }
 
 sub help_section_subcommands {
     my ($self, $r) = @_;
 
     my $verbose = $r->{_help_verbose};
     return unless $self->subcommands && !$r->{subcommand_name};
     my $scs = $self->list_subcommands;
 
     my @scs = sort keys %$scs;
     my @shown_scs;
     for my $scn (@scs) {
         my $sc = $scs->{$scn};
         next unless $sc->{show_in_help} // 1;
         $sc->{name} = $scn;
         push @shown_scs, $sc;
     }
 
     my $some_not_shown = @scs > @shown_scs;
     $r->{_help_hide_some_subcommands} = 1 if $some_not_shown;
 
     $self->_help_add_heading(
         $r, $some_not_shown ? __("Popular subcommands") : __("Subcommands"));
 
     my $long_mode = $verbose || @shown_scs < 12;
     if ($long_mode) {
         for (@shown_scs) {
             my $summary = rimeta($_)->langprop("summary");
             $self->_help_add_row(
                 $r,
                 [$self->_color('program_name', $_->{name}), $summary],
                 {column_widths=>[-17, -40], indent=>1});
         }
     } else {
         my $tw = $self->term_width;
         my $columns = int($tw/25); $columns = 1 if $columns < 1;
             while (1) {
                 my @row;
                 for (1..$columns) {
                     last unless @shown_scs;
                     my $sc = shift @shown_scs;
                     push @row, $sc->{name};
                 }
                 last unless @row;
                 for (@row+1 .. $columns) { push @row, "" }
                 $self->_help_add_row($r, \@row, {indent=>1});
             }
 
     }
 }
 
 sub help_section_hints {
     my ($self, $r) = @_;
 
     my $verbose = $r->{_help_verbose};
     my @hints;
     unless ($verbose) {
         push @hints, N__("For more complete help, use '--help --verbose'");
     }
     if ($r->{_help_hide_some_subcommands}) {
         push @hints,
             N__("To see all available subcommands, use '--subcommands'");
     }
     return unless @hints;
 
     $self->_help_add_row(
         $r, [join(" ", map { __($_)."." } @hints)], {wrap=>1});
 }
 
 sub help_section_description {
     my ($self, $r) = @_;
 
     my $desc = rimeta($r->{_help_meta})->langprop("description") //
         $self->description;
     return unless $desc;
 
     $self->_help_add_heading($r, __("Description"));
     $self->_help_add_row($r, [$desc], {wrap=>1, indent=>1});
 }
 
 sub help_section_examples {
     my ($self, $r) = @_;
 
     my $verbose = $r->{_help_verbose};
     my $meta = $r->{_help_meta};
     my $egs = $r->{_help_clidocdata}{examples};
     return unless $egs && @$egs;
 
     $self->_help_add_heading($r, __("Examples"));
     my $pn = $self->_color(
         'program_name', $self->get_program_and_subcommand_name($r));
     for my $eg (@$egs) {
         my $cmdline = $eg->{cmdline};
         $cmdline =~ s/\[\[prog\]\]/$pn/;
         $self->_help_add_row($r, ["% $cmdline"], {indent=>1});
         if ($verbose) {
             my $ct = "";
             if ($eg->{summary}) { $ct .= "$eg->{summary}." }
             if ($eg->{description}) { $ct .= "\n\n$eg->{description}" }
             $self->_help_add_row($r, [$ct], {indent=>2}) if $ct;
         }
     }
 }
 
 sub help_section_result {
     my ($self, $r) = @_;
 
     my $meta   = $r->{_help_meta};
     my $rmeta  = $meta->{result};
     my $rmetao = rimeta($rmeta);
     my $text;
 
     my $summary = $rmetao->langprop('summary') // '';
     my $desc    = $rmetao->langprop('description') // '';
     $text = $summary . ($summary ? "\n\n" : "") . $desc;
 
     my %handlers;
     for my $k0 (keys %$rmeta) {
         my $v = $rmeta->{$k0};
 
         my $k = $k0; $k =~ s/\..+//;
         next if $k =~ /\A_/;
 
         next if $k =~ /\A(
                            summary|description|tags|default_lang|
                            schema|
                            x
                        )\z/x;
 
         require "Perinci/Sub/Property/result/$k.pm";
         my $meth = "help_hookmeta_result__$k";
         unless ($self->can($meth)) {
             die "No help handler for property result/$k0 ($meth)";
         }
         my $hmeta = $self->$meth;
         $handlers{$k} = {
             prio => $hmeta->{prio},
             meth => "help_hook_result__$k",
         };
     }
 
     for my $k (sort {$handlers{$a}{prio} <=> $handlers{$b}{prio}}
                    keys %handlers) {
         my $h = $handlers{$k};
         my $meth = $h->{meth};
         my $t = $self->$meth($r);
         $text .= $t if $t;
     }
 
     return unless length $text;
 
     $self->_help_add_heading($r, __("Result"));
     $self->_help_add_row($r, [$text], {wrap=>1, indent=>1});
 }
 
 sub help_section_links {
 }
 
 sub action_help {
     my ($self, $r) = @_;
 
     $r->{_help_buf} = '';
 
     my $verbose = $ENV{VERBOSE} // 0;
     local $r->{_help_verbose} = $verbose;
 
     unless ($r->{_help_meta}) {
         my $url = $r->{subcommand_data}{url} // $self->url;
         my $res = $self->riap_client->request(info => $url);
         die [500, "Can't info '$url': $res->[0] - $res->[1]"]
             unless $res->[0] == 200;
         $r->{_help_info} = $res->[2];
         $res = $self->riap_client->request(meta => $url);
         die [500, "Can't meta '$url': $res->[0] - $res->[1]"]
             unless $res->[0] == 200;
         $r->{_help_meta} = $res->[2]; 
     }
 
     unless ($r->{_help_clidocdata}) {
         require Perinci::Sub::To::CLIDocData;
         my $res = Perinci::Sub::To::CLIDocData::gen_cli_doc_data_from_meta(
             meta => $r->{_help_meta}, meta_is_normalized => 1,
             common_opts  => $self->common_opts,
             per_arg_json => $self->per_arg_json,
             per_arg_yaml => $self->per_arg_yaml,
         );
         die [500, "Can't gen_cli_doc_data_from_meta: $res->[0] - $res->[1]"]
             unless $res->[0] == 200;
         $r->{_help_clidocdata} = $res->[2]; 
     }
 
     if ($verbose && !defined($ENV{COLUMNS}) && $self->term_width > 80) {
         $self->term_width(80);
     }
 
     my @hsects;
     if ($verbose) {
         @hsects = (
             'summary',
             'usage',
             'subcommands',
             'examples',
             'description',
             'options',
             'result',
             'links',
             'hints',
         );
     } else {
         @hsects = (
             'summary',
             'usage',
             'subcommands',
             'examples',
             'options',
             'hints',
         );
     }
 
     for my $s (@hsects) {
         my $meth = "help_section_$s";
         $self->$meth($r);
     }
     $self->_help_draw_curtbl($r);
     [200, "OK", $r->{_help_buf}, {"cmdline.skip_format"=>1}];
 }
 
 1;
 
 __END__
 
### Perinci/CmdLine/Help.pm ###
 package Perinci::CmdLine::Help;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.08'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(gen_help);
 
 our %SPEC;
 
 $SPEC{gen_help} = {
     v => 1.1,
     summary => 'Generate help message for Perinci::CmdLine-based app',
     args => {
         program_name => {
             schema => 'str*',
             req => 1,
         },
         program_summary => {
             schema => 'str*',
         },
         subcommands => {
             schema => 'hash',
         },
         meta => {
             summary => 'Function metadata, must be normalized',
             schema => 'hash*',
             req => 1,
         },
         common_opts => {
             schema => 'hash*',
             default => {},
         },
         per_arg_json => {
             schema => 'bool*',
         },
         per_arg_yaml => {
             schema => 'bool*',
         },
     },
 };
 sub gen_help {
     my %args = @_;
 
     my $meta = $args{meta};
     my $common_opts = $args{common_opts} // {};
 
     my @help;
 
     my $progname = $args{program_name};
     push @help, $progname;
     {
         my $sum = $args{program_summary} // $meta->{summary};
         last unless $sum;
         push @help, " - ", $sum, "\n";
     }
 
     my $clidocdata;
 
     push @help, "\nUsage:\n";
     {
         for (sort {
             ($common_opts->{$a}{order} // 99) <=>
                 ($common_opts->{$b}{order} // 99) ||
                     $a cmp $b
             } keys %$common_opts) {
             my $co = $common_opts->{$_};
             next unless $co->{usage};
             push @help, "  $progname $co->{usage}\n";
         }
 
         require Perinci::Sub::To::CLIDocData;
         my $res = Perinci::Sub::To::CLIDocData::gen_cli_doc_data_from_meta(
             meta => $meta, meta_is_normalized => 1,
             common_opts  => $common_opts,
             per_arg_json => $args{per_arg_json},
             per_arg_yaml => $args{per_arg_yaml},
         );
         die [500, "gen_cli_doc_data_from_meta failed: ".
                  "$res->[0] - $res->[1]"] unless $res->[0] == 200;
         $clidocdata = $res->[2];
         my $usage = $clidocdata->{usage_line};
         $usage =~ s/\[\[prog\]\]/$progname/;
         push @help, "  $usage\n";
     }
 
     {
         my $subcommands = $args{subcommands} or last;
         push @help, "\nSubcommands:\n";
         if (keys(%$subcommands) >= 12) {
             no warnings 'once';
             require Text::Wrap;
             local $Text::Wrap::columns = $ENV{COLUMNS} // 80;
             push @help, Text::Wrap::wrap(
                 "  ", "  ", join(", ", sort keys %$subcommands)), "\n";
         } else {
             for my $sc_name (sort keys %$subcommands) {
                 my $sc_spec = $subcommands->{$sc_name};
                 next unless $sc_spec->{show_in_help} //1;
                 push @help, "  $sc_name\n";
             }
         }
     }
 
     {
         last unless @{ $clidocdata->{examples} };
         push @help, "\nExamples:\n";
         my $i = 0;
         my $egs = $clidocdata->{examples};
         for my $eg (@$egs) {
             $i++;
             my $cmdline = $eg->{cmdline};
             $cmdline =~ s/\[\[prog\]\]/$progname/;
             push @help, "  $eg->{summary}:\n" if $eg->{summary};
             push @help, "  % $cmdline\n";
             push @help, "\n" if $eg->{summary} && $i < @$egs;
         }
     }
 
     {
         my $desc = $args{program_description} // $meta->{description};
         last unless $desc;
         $desc =~ s/\A\n+//;
         $desc =~ s/\n+\z//;
         push @help, "\n", $desc, "\n" if $desc =~ /\S/;
     }
 
     {
         require Data::Dmp;
 
         my $opts = $clidocdata->{opts};
         last unless keys %$opts;
 
         my %options_by_cat; 
         for my $optkey (keys %$opts) {
             for my $cat (@{ $opts->{$optkey}{categories} }) {
                 push @{ $options_by_cat{$cat} }, $optkey;
             }
         }
 
         my $cats_spec = $clidocdata->{option_categories};
         for my $cat (sort {
             ($cats_spec->{$a}{order} // 50) <=> ($cats_spec->{$b}{order} // 50)
                 || $a cmp $b }
                          keys %options_by_cat) {
             my @opts = sort {length($b)<=>length($a)}
                 @{ $options_by_cat{$cat} };
             my $len = length($opts[0]);
             @opts = sort {
                 (my $a_without_dash = $a) =~ s/^-+//;
                 (my $b_without_dash = $b) =~ s/^-+//;
                 lc($a) cmp lc($b);
             } @opts;
             push @help, "\n$cat:\n";
             for my $opt (@opts) {
                 my $ospec = $opts->{$opt};
                 my $arg_spec = $ospec->{arg_spec};
                 my $is_bool = $arg_spec->{schema} &&
                     $arg_spec->{schema}[0] eq 'bool';
                 my $show_default = exists($ospec->{default}) &&
                     !$is_bool && !$ospec->{is_base64} &&
                         !$ospec->{is_json} && !$ospec->{is_yaml} &&
                             !$ospec->{is_alias};
 
                 my $add_sum = '';
                 if ($ospec->{is_base64}) {
                     $add_sum = " (base64-encoded)";
                 } elsif ($ospec->{is_json}) {
                     $add_sum = " (JSON-encoded)";
                 } elsif ($ospec->{is_yaml}) {
                     $add_sum = " (YAML-encoded)";
                 }
 
                 my $argv = '';
                 if (!$ospec->{main_opt} && defined($ospec->{pos})) {
                     if ($ospec->{greedy}) {
                         $argv = " (=arg[$ospec->{pos}-])";
                     } else {
                         $argv = " (=arg[$ospec->{pos}])";
                     }
                 }
 
                 my $cmdline_src = '';
                 if (!$ospec->{main_opt} && defined($arg_spec->{cmdline_src})) {
                     $cmdline_src = " (or from $arg_spec->{cmdline_src})";
                     $cmdline_src =~ s!_or_!/!g;
                 }
 
                 push @help, sprintf(
                     "  %-${len}s  %s%s%s%s%s\n",
                     $opt,
                     $ospec->{summary}//'',
                     $add_sum,
                     $argv,
                     $cmdline_src,
                     ($show_default && defined($ospec->{default}) ?
                          " [".Data::Dmp::dmp($ospec->{default})."]":""),
 
                 );
             }
         }
     }
 
     [200, "OK", join("", @help)];
 }
 
 1;
 
 __END__
 
### Perinci/CmdLine/Lite.pm ###
 package Perinci::CmdLine::Lite;
 
 our $DATE = '2015-10-20'; 
 our $VERSION = '1.36'; 
 
 use 5.010001;
 use Log::Any::IfLOG '$log';
 
 use List::Util qw(first);
 use Mo qw(build default);
 extends 'Perinci::CmdLine::Base';
 
 
 has default_prompt_template => (
     is=>'rw',
     default => 'Enter %s: ',
 );
 has log => (
     is=>'rw',
     default => sub {
         if (defined $ENV{LOG}) {
             return $ENV{LOG};
         } elsif ($ENV{LOG_LEVEL} && $ENV{LOG_LEVEL} =~ /^(off|none)$/) {
             return 0;
         } elsif ($ENV{LOG_LEVEL} || $ENV{TRACE} || $ENV{DEBUG} ||
                      $ENV{VERBOSE} || $ENV{QUIET}) {
             return 0;
         }
         0;
     },
 );
 has log_level => (
     is=>'rw',
     default => sub {
         if ($ENV{LOG_LEVEL}) {
             return $ENV{LOG_LEVEL};
         } elsif ($ENV{TRACE}) {
             return 'trace';
         } elsif ($ENV{DEBUG}) {
             return 'debug';
         } elsif ($ENV{VERBOSE}) {
             return 'info';
         } elsif ($ENV{QUIET}) {
             return 'error';
         }
         'warning';
     },
 );
 has validate_args => (
     is=>'rw',
     default => 1,
 );
 
 my $formats = [qw/text text-simple text-pretty json json-pretty/];
 
 sub BUILD {
     my ($self, $args) = @_;
 
     if (!$self->{riap_client}) {
         require Perinci::Access::Lite;
         my %rcargs = (
             riap_version => $self->{riap_version} // 1.1,
             %{ $self->{riap_client_args} // {} },
         );
         $self->{riap_client} = Perinci::Access::Lite->new(%rcargs);
     }
 
     if (!$self->{actions}) {
         $self->{actions} = {
             call => {},
             version => {},
             subcommands => {},
             help => {},
         };
     }
 
     my $_t = sub {
         no warnings;
         my $co_name = shift;
         my $href = $Perinci::CmdLine::Base::copts{$co_name};
         %$href;
     };
 
     if (!$self->{common_opts}) {
         my $copts = {};
 
         $copts->{version}   = { $_t->('version'), };
         $copts->{help}      = { $_t->('help'), };
 
         unless ($self->skip_format) {
             $copts->{format}    = {
                 $_t->('format'),
                 schema => ['str*' => in => $formats],
             };
             $copts->{json}      = { $_t->('json'), };
             $copts->{naked_res} = { $_t->('naked_res'), };
         }
         if ($self->subcommands) {
             $copts->{subcommands} = { $_t->('subcommands'), };
         }
         if ($self->default_subcommand) {
             $copts->{cmd} = { $_t->('cmd') };
         }
         if ($self->read_config) {
             $copts->{config_path}    = { $_t->('config_path') };
             $copts->{no_config}      = { $_t->('no_config') };
             $copts->{config_profile} = { $_t->('config_profile') };
         }
         if ($self->read_env) {
             $copts->{no_env} = { $_t->('no_env') };
         }
         if ($self->log) {
             $copts->{log_level} = { $_t->('log_level'), };
             $copts->{trace}     = { $_t->('trace'), };
             $copts->{debug}     = { $_t->('debug'), };
             $copts->{verbose}   = { $_t->('verbose'), };
             $copts->{quiet}     = { $_t->('quiet'), };
         }
         $self->{common_opts} = $copts;
     }
 
     $self->{formats} //= $formats;
 
     $self->{per_arg_json} //= 1;
 }
 
 my $setup_progress;
 sub _setup_progress_output {
     my $self = shift;
 
     return unless $ENV{PROGRESS} // (-t STDOUT);
 
     require Progress::Any::Output;
     Progress::Any::Output->set("TermProgressBarColor");
     $setup_progress = 1;
 }
 
 sub _unsetup_progress_output {
     my $self = shift;
 
     return unless $setup_progress;
     my $out = $Progress::Any::outputs{''}[0];
     $out->cleanup if $out->can("cleanup");
     $setup_progress = 0;
 }
 
 sub hook_after_parse_argv {
     my ($self, $r) = @_;
 
     my $ass  = $r->{meta}{args} // {};
     my $args = $r->{args};
     for (keys %$ass) {
         next if exists $args->{$_};
         my $as = $ass->{$_};
         if (exists $as->{default}) {
             $args->{$_} = $as->{default};
         } elsif ($as->{schema} && exists $as->{schema}[1]{default}) {
             $args->{$_} = $as->{schema}[1]{default};
         }
     }
 
     if ($self->log) {
         require Log::Any::Adapter;
         Log::Any::Adapter->set(
             'Screen',
             min_level => $r->{log_level} // $self->log_level,
             formatter => sub { $self->program_name . ": $_[1]" },
         );
     }
 }
 
 sub hook_before_action {
     my ($self, $r) = @_;
 
   VALIDATE_ARGS:
     {
         last unless $self->validate_args;
 
         last unless $r->{action} eq 'call';
 
         my $meta = $r->{meta};
 
         last if $meta->{'x.perinci.sub.wrapper.logs'} &&
             (grep { $_->{validate_args} }
              @{ $meta->{'x.perinci.sub.wrapper.logs'} });
 
         require Data::Sah;
 
         my %validators; 
 
         for my $arg (sort keys %{ $meta->{args} // {} }) {
             next unless exists($r->{args}{$arg});
 
             next if $meta->{args}{$arg}{stream};
 
             my $schema = $meta->{args}{$arg}{schema};
             next unless $schema;
             unless ($validators{"$schema"}) {
                 my $v = Data::Sah::gen_validator($schema, {
                     return_type => 'str',
                     schema_is_normalized => 1,
                 });
                 $validators{"$schema"} = $v;
             }
             my $res = $validators{"$schema"}->($r->{args}{$arg});
             if ($res) {
                 die [400, "Argument '$arg' fails validation: $res"];
             }
         }
 
         if ($meta->{args_rels}) {
             my $schema = [hash => $meta->{args_rels}];
             my $sah = Data::Sah->new;
             my $hc  = $sah->get_compiler("human");
             my $cd  = $hc->init_cd;
             $cd->{args}{lang} //= $cd->{default_lang};
             my $v = Data::Sah::gen_validator($schema, {
                 return_type => 'str',
                 human_hash_values => {
                     field  => $hc->_xlt($cd, "argument"),
                     fields => $hc->_xlt($cd, "arguments"),
                 },
             });
             my $res = $v->($r->{args});
             if ($res) {
                 die [400, $res];
             }
         }
 
     }
 }
 
 sub hook_format_result {
     require Perinci::Result::Format::Lite;
     my ($self, $r) = @_;
 
     my $fmt = $r->{format} // 'text';
 
     my $fres = Perinci::Result::Format::Lite::format(
         $r->{res}, $fmt, $r->{naked_res});
 
     if ($fmt =~ /text/ && $r->{res}[0] =~ /\A[45]/ && defined($r->{res}[1])) {
         $fres = $self->program_name . ": $fres";
     }
 
     $fres;
 }
 
 sub hook_format_row {
     my ($self, $r, $row) = @_;
 
     if (ref($row) eq 'ARRAY') {
         return join("\t", @$row) . "\n";
     } else {
         return ($row // "") . "\n";
     }
 }
 
 sub hook_display_result {
     my ($self, $r) = @_;
     $self->display_result($r);
 }
 
 sub hook_after_run {
     my ($self, $r) = @_;
     $self->_unsetup_progress_output;
 }
 
 sub hook_after_get_meta {
     my ($self, $r) = @_;
 
     require Perinci::Object;
     if (Perinci::Object::risub($r->{meta})->can_dry_run) {
         $self->common_opts->{dry_run} = {
             getopt  => 'dry-run',
             summary => "Run in simulation mode (also via DRY_RUN=1)",
             handler => sub {
                 my ($go, $val, $r) = @_;
                 $log->debugf("[pericmd] Dry-run mode is activated");
                 $r->{dry_run} = 1;
             },
         };
     }
 
     if ($r->{meta}{deps}) {
         require Perinci::Sub::DepChecker;
         my $res = Perinci::Sub::DepChecker::check_deps($r->{meta}{deps});
         if ($res) {
             die [412, "Dependency failed: $res"];
         }
     }
 }
 
 sub action_subcommands {
     my ($self, $r) = @_;
 
     if (!$self->subcommands) {
         say "There are no subcommands.";
         return 0;
     }
 
     say "Available subcommands:";
     my $scs = $self->list_subcommands;
     my $longest = 6;
     for (keys %$scs) { my $l = length; $longest = $l if $l > $longest }
     [200, "OK",
      join("",
           (map { sprintf("  %-${longest}s  %s\n",$_,$scs->{$_}{summary}//"") }
                sort keys %$scs),
       )];
 }
 
 sub action_version {
     no strict 'refs';
 
     my ($self, $r) = @_;
 
     my @text;
 
     {
         my $meta = $r->{meta} = $self->get_meta($r, $self->url);
         push @text, $self->get_program_and_subcommand_name($r),
             " version ", ($meta->{entity_v} // "?"),
             ($meta->{entity_date} ? " ($meta->{entity_date})" : ''),
             "\n";
         for my $mod (@{ $meta->{'x.dynamic_generator_modules'} // [] }) {
             push @text, "  $mod version ", ${"$mod\::VERSION"},
                 (${"$mod\::DATE"} ? " (".${"$mod\::DATE"}.")" : ""),
                     "\n";
         }
     }
 
     for my $url (@{ $self->extra_urls_for_version // [] }) {
         my $meta = $self->get_meta($r, $url);
         push @text, "  $url version ", ($meta->{entity_v} // "?"),
             ($meta->{entity_date} ? " ($meta->{entity_date})" : ''),
             "\n";
     }
 
     push @text, "  ", __PACKAGE__,
         " version ", ($Perinci::CmdLine::Lite::VERSION // "?"),
         ($Perinci::CmdLine::Lite::DATE ?
          " ($Perinci::CmdLine::Lite::DATE)":''),
         "\n";
 
     [200, "OK", join("", @text)];
 }
 
 sub action_help {
     require Perinci::CmdLine::Help;
 
     my ($self, $r) = @_;
 
     my @help;
     my $scn    = $r->{subcommand_name};
     my $scd    = $r->{subcommand_data};
 
     my $meta = $self->get_meta($r, $scd->{url} // $self->{url});
 
     my $common_opts = { %{$self->common_opts} };
 
     my $has_sc_no_sc = $self->subcommands && !length($r->{subcommand_name});
     delete $common_opts->{subcommands} if $self->subcommands && !$has_sc_no_sc;
 
     my $res = Perinci::CmdLine::Help::gen_help(
         program_name => $self->get_program_and_subcommand_name($r),
         program_summary => ($scd ? $scd->{summary}:undef ) // $meta->{summary},
         program_description => $scd ? $scd->{description} : undef,
         meta => $meta,
         subcommands => $has_sc_no_sc ? $self->list_subcommands : undef,
         common_opts => $common_opts,
         per_arg_json => $self->per_arg_json,
         per_arg_yaml => $self->per_arg_yaml,
     );
 
     $res->[3]{"cmdline.skip_format"} = 1;
     $res;
 }
 
 sub action_call {
     my ($self, $r) = @_;
 
     my %extra;
     if ($r->{send_argv}) {
         $log->tracef("[pericmd] Sending argv to server: %s", $extra{argv});
         $extra{argv} = $r->{orig_argv};
     } else {
         my %extra_args;
         $extra_args{-dry_run} = 1 if $r->{dry_run};
         $extra{args} = {%extra_args, %{$r->{args}}};
     }
 
     $extra{stream_arg} = 1 if $r->{stream_arg};
 
     my $url = $r->{subcommand_data}{url};
 
     $log->tracef("[pericmd] Riap request: action=call, url=%s", $url);
 
 
     if ($r->{meta}{features}{progress}) {
         $self->_setup_progress_output;
     }
 
     $self->riap_client->request(
         call => $url, \%extra);
 }
 
 1;
 
 __END__
 
### Perinci/CmdLine/Util/Config.pm ###
 package Perinci::CmdLine::Util::Config;
 
 our $DATE = '2015-10-20'; 
 our $VERSION = '1.36'; 
 
 use 5.010;
 use strict;
 use warnings;
 use Log::Any::IfLOG '$log';
 
 use PERLANCAR::File::HomeDir qw(get_my_home_dir);
 
 our %SPEC;
 
 $SPEC{get_default_config_dirs} = {
     v => 1.1,
     args => {},
 };
 sub get_default_config_dirs {
     my @dirs;
     local $PERLANCAR::File::HomeDir::DIE_ON_FAILURE = 1;
     my $home = get_my_home_dir();
     if ($^O eq 'MSWin32') {
         push @dirs, $home;
     } else {
         push @dirs, "$home/.config", $home, "/etc";
     }
     \@dirs;
 }
 
 $SPEC{read_config} = {
     v => 1.1,
     args => {
         config_paths => {},
         config_filenames => {},
         config_dirs => {},
         program_name => {},
     },
 };
 sub read_config {
     require Config::IOD::Reader;
 
     my %args = @_;
 
     my $config_dirs = $args{config_dirs} // get_default_config_dirs();
 
     my $paths;
     if ($args{config_paths}) {
         $paths = $args{config_paths};
     } else {
         my $name = $args{config_filename} //
             $args{program_name} . ".conf";
         for my $dir (@$config_dirs) {
             my $path = "$dir/" . $name;
             push @$paths, $path if -e $path;
         }
     }
 
     my $reader = Config::IOD::Reader->new;
     my %res;
     my @read;
     for my $path (@$paths) {
         my $hoh = $reader->read_file($path);
         push @read, $path;
         for my $section (keys %$hoh) {
             my $hash = $hoh->{$section};
             for (keys %$hash) {
                 $res{$section}{$_} = $hash->{$_};
             }
         }
     }
     [200, "OK", \%res, {'func.read_files' => \@read}];
 }
 
 $SPEC{get_args_from_config} = {
     v => 1.1,
     args => {
         r => {},
         config => {},
         args => {},
         subcommand_name => {},
         config_profile => {},
         common_opts => {},
         meta => {},
         meta_is_normalized => {},
     },
 };
 sub get_args_from_config {
     my %fargs = @_;
 
     my $r       = $fargs{r};
     my $conf    = $fargs{config};
     my $scn     = $fargs{subcommand_name} // '';
     my $profile = $fargs{config_profile};
     my $args    = $fargs{args} // {};
     my $copts   = $fargs{common_opts};
     my $meta    = $fargs{meta};
     my $found;
 
     unless ($fargs{meta_is_normalized}) {
         require Perinci::Sub::Normalize;
         $meta = Perinci::Sub::Normalize::normalize_function_metadata($meta);
     }
 
     my @sections = sort {
         ($a eq 'GLOBAL' ? 0:1) <=> ($b eq 'GLOBAL' ? 0:1) ||
             $a cmp $b
         } keys %$conf;
 
     my %seen_profiles; 
     for my $section (@sections) {
         my ($sect_scn, $sect_profile);
         if ($section =~ /\Aprofile=(.*)\z/) {
             $sect_scn = 'GLOBAL';
             $sect_profile = $1;
         } elsif ($section =~ /\A\S+\z/) {
             $sect_scn = $section;
         } elsif ($section =~ /\A(\S+)\s+profile=(.*)\z/) {
             $sect_scn = $1;
             $sect_profile = $2;
         } else {
             die [412, "Error in config file: invalid section name ".
                      "'$section', please use subcommand name + optional ".
                          "' profile=PROFILE' only"];
         }
         $seen_profiles{$sect_profile}++ if defined $sect_profile;
         if (length $scn) {
             next if $sect_scn ne 'GLOBAL' && $sect_scn ne $scn;
         } else {
             next if $sect_scn ne 'GLOBAL';
         }
         if (defined $profile) {
             next if defined($sect_profile) && $sect_profile ne $profile;
             $found++ if defined($sect_profile) && $sect_profile eq $profile;
         } else {
             next if defined($sect_profile);
         }
 
         my $as = $meta->{args} // {};
         for my $k (keys %{ $conf->{$section} }) {
             my $v = $conf->{$section}{$k};
             if ($copts->{$k} && $copts->{$k}{is_settable_via_config}) {
                 my $sch = $copts->{$k}{schema};
                 if ($sch) {
                     require Data::Sah::Normalize;
                     $sch = Data::Sah::Normalize::normalize_schema($sch);
                     if (ref($v) ne 'ARRAY' && $sch->[0] eq 'array') {
                         $v = [$v];
                     }
                 }
                 $copts->{$k}{handler}->(undef, $v, $r);
             } else {
                 $k =~ s/\.arg\z//;
 
                 if (ref($v) ne 'ARRAY' && $as->{$k} && $as->{$k}{schema} &&
                         $as->{$k}{schema}[0] eq 'array') {
                     $v = [$v];
                 }
                 $args->{$k} = $v;
             }
         }
     }
     $log->tracef("[pericmd] Seen config profiles: %s",
                  [sort keys %seen_profiles]);
 
     [200, "OK", $args, {'func.found'=>$found}];
 }
 
 1;
 
 __END__
 
### Perinci/Object.pm ###
 package Perinci::Object;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.24'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA    = qw(Exporter);
 our @EXPORT = qw(rimeta risub rivar ripkg envres envresmulti riresmeta);
 
 sub rimeta {
     require Perinci::Object::Metadata;
     Perinci::Object::Metadata->new(@_);
 }
 
 sub risub {
     require Perinci::Object::Function;
     Perinci::Object::Function->new(@_);
 }
 
 sub rivar {
     require Perinci::Object::Variable;
     Perinci::Object::Variable->new(@_);
 }
 
 sub ripkg {
     require Perinci::Object::Package;
     Perinci::Object::Package->new(@_);
 }
 
 sub envres {
     require Perinci::Object::EnvResult;
     Perinci::Object::EnvResult->new(@_);
 }
 
 sub envresmulti {
     require Perinci::Object::EnvResultMulti;
     Perinci::Object::EnvResultMulti->new(@_);
 }
 
 sub riresmeta {
     require Perinci::Object::ResMeta;
     Perinci::Object::ResMeta->new(@_);
 }
 
 1;
 
 __END__
 
### Perinci/Object/EnvResult.pm ###
 package Perinci::Object::EnvResult;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.24'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 sub new {
     my ($class, $res) = @_;
     $res //= [0, "", undef];
     my $obj = \$res;
     bless $obj, $class;
 }
 
 sub new_ok {
     my $class = shift;
     my $res = [200, "OK"];
     if (@_) {
         push @$res, $_[0];
     }
     $class->new($res);
 }
 
 sub status {
     my ($self, $new) = @_;
     if (defined $new) {
         die "Status must be an integer between 100 and 555" unless
             int($new) eq $new && $new >= 100 && $new <= 555;
         my $old = ${$self}->[0];
         ${$self}->[0] = $new;
         return $old;
     }
     ${$self}->[0];
 }
 
 sub message {
     my ($self, $new) = @_;
     if (defined $new) {
         die "Extra must be a string" if ref($new);
         my $old = ${$self}->[1];
         ${$self}->[1] = $new;
         return $old;
     }
     ${$self}->[1];
 }
 
 
 sub payload {
     my ($self, $new) = @_;
     if (defined $new) {
         my $old = ${$self}->[2];
         ${$self}->[2] = $new;
         return $old;
     }
     ${$self}->[2];
 }
 
 sub meta {
     my ($self, $new) = @_;
     if (defined $new) {
         die "Extra must be a hashref" unless ref($new) eq 'HASH';
         my $old = ${$self}->[3];
         ${$self}->[3] = $new;
         return $old;
     }
     ${$self}->[3];
 }
 
 sub is_success {
     my ($self) = @_;
     my $status = ${$self}->[0];
     $status >= 200 && $status <= 299;
 }
 
 sub as_struct {
     my ($self) = @_;
     ${$self};
 }
 
 1;
 
 __END__
 
### Perinci/Object/EnvResultMulti.pm ###
 package Perinci::Object::EnvResultMulti;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.24'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use parent qw(Perinci::Object::EnvResult);
 
 sub new {
     my ($class, $res) = @_;
     $res //= [200, "Success/no items"];
     my $obj = \$res;
     bless $obj, $class;
 }
 
 sub add_result {
     my ($self, $status, $message, $extra) = @_;
     my $num_ok  = 0;
     my $num_nok = 0;
 
     push @{ ${$self}->[3]{results} },
         {%{ $extra // {} }, status=>$status, message=>$message};
     for (@{ ${$self}->[3]{results} // [] }) {
         if ($_->{status} =~ /\A(2|304)/) {
             $num_ok++;
         } else {
             $num_nok++;
         }
     }
     if ($num_ok) {
         if ($num_nok) {
             ${$self}->[0] = 207;
             ${$self}->[1] = "Partial success";
         } else {
             ${$self}->[0] = 200;
             ${$self}->[1] = "All success";
         }
     } else {
         ${$self}->[0] = $status;
         ${$self}->[1] = $message;
     }
 }
 
 1;
 
 __END__
 
### Perinci/Object/Function.pm ###
 package Perinci::Object::Function;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.24'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use parent qw(Perinci::Object::Metadata);
 
 sub type { "function" }
 
 sub feature {
     my $self = shift;
     my $name = shift;
     if (@_) {
         die "1.0 can't set feature" if $self->v eq 1.0;
         my $value = shift;
         ${$self}->{features} //= {};
         my $old = ${$self}->{features}{$name};
         ${$self}->{features}{$name} = $value;
         return $old;
     } else {
         ${$self}->{features}{$name};
     }
 }
 
 sub features {
     my $self = shift;
     ${$self}->{features} // {};
 }
 
 sub can_dry_run {
     my $self = shift;
     my $ff = ${$self}->{features} // {};
     $ff->{dry_run} // $ff->{tx} && $ff->{tx}{v} == 2;
 }
 
 sub arg {
     my $self = shift;
     my $name = shift;
     if (@_) {
         die "1.0 can't set arg" if $self->v eq 1.0;
         my $value = shift;
         ${$self}->{args} //= {};
         my $old = ${$self}->{args}{$name};
         ${$self}->{args}{$name} = $value;
         return $old;
     } else {
         ${$self}->{args}{$name};
     }
 }
 
 1;
 
 __END__
 
### Perinci/Object/Metadata.pm ###
 package Perinci::Object::Metadata;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.24'; 
 
 use 5.010;
 use strict;
 use warnings;
 use String::Trim::More qw(trim_blank_lines);
 
 sub new {
     my ($class, $meta) = @_;
     $meta //= {};
     my $obj = \$meta;
     bless $obj, $class;
 }
 
 sub v {
     my $self = shift;
     ${$self}->{v} // 1.0;
 }
 
 sub type {
     die "BUG: type() must be subclassed";
 }
 
 sub as_struct {
     my $self = shift;
     ${$self};
 }
 
 sub langprop {
     my $self = shift;
     my $opts;
     if (ref($_[0]) eq 'HASH') {
         $opts = shift;
     } else {
         $opts = {};
     }
     my $prop = shift;
 
     my $deflang = ${$self}->{default_lang} // "en_US";
     my $olang   = $opts->{lang} || $ENV{LANGUAGE} || $ENV{LANG} || $deflang;
     $olang =~ s/\W.+//; 
     $olang = "en_US" if $olang eq 'C';
     (my $olang2 = $olang) =~ s/\A([a-z]{2})_[A-Z]{2}\z/$1/; 
     my $mark    = $opts->{mark_different_lang} // 1;
 
     my @k;
     if ($olang eq $deflang) {
         @k = ([$olang, $prop, 0]);
     } else {
         @k = (
             [$olang, "$prop.alt.lang.$olang", 0],
             ([$olang2, "$prop.alt.lang.$olang2", 0]) x !!($olang2 ne $olang),
             [$deflang, $prop, $mark],
         );
     }
 
     my $v;
   GET:
     for my $k (@k) {
         $v = ${$self}->{$k->[1]};
         if (defined $v) {
             if ($k->[2]) {
                 my $has_nl = $v =~ s/\n\z//;
                 $v = "{$olang|$k->[0] $v}" . ($has_nl ? "\n" : "");
             }
             $v = trim_blank_lines($v);
             last GET;
         }
     }
 
     if (@_) {
         ${$self}->{$k[0][1]} = $_[0];
     }
 
     $v;
 }
 
 sub name {
     my $self = shift;
     my $opts;
     if (@_ && ref($_[0]) eq 'HASH') {
         $opts = shift;
     } else {
         $opts = {};
     }
     $self->langprop($opts, "name", @_);
 }
 
 sub caption {
     my $self = shift;
     my $opts;
     if (@_ && ref($_[0]) eq 'HASH') {
         $opts = shift;
     } else {
         $opts = {};
     }
     $self->langprop($opts, "caption", @_);
 }
 
 sub summary {
     my $self = shift;
     my $opts;
     if (@_ && ref($_[0]) eq 'HASH') {
         $opts = shift;
     } else {
         $opts = {};
     }
     $self->langprop($opts, "summary", @_);
 }
 
 sub description {
     my $self = shift;
     my $opts;
     if (@_ && ref($_[0]) eq 'HASH') {
         $opts = shift;
     } else {
         $opts = {};
     }
     $self->langprop($opts, "description", @_);
 }
 
 1;
 
 __END__
 
### Perinci/Object/Package.pm ###
 package Perinci::Object::Package;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.24'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use parent qw(Perinci::Object::Metadata);
 
 sub type { "package" }
 
 1;
 
 __END__
 
### Perinci/Object/ResMeta.pm ###
 package Perinci::Object::ResMeta;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.24'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use parent qw(Perinci::Object::Metadata);
 
 sub type { "resmeta" }
 
 1;
 
 __END__
 
### Perinci/Object/Variable.pm ###
 package Perinci::Object::Variable;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.24'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use parent qw(Perinci::Object::Metadata);
 
 sub type { "variable" }
 
 1;
 
 __END__
 
### Perinci/Result/Format.pm ###
 package Perinci::Result::Format;
 
 our $DATE = '2015-10-20'; 
 our $VERSION = '0.43'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 our $Enable_Decoration = 1;
 our $Enable_Cleansing  = 0;
 
 
 
 my $format_text = sub {
     my ($format, $res) = @_;
 
     my $stack_trace_printed;
 
     my $print_err = sub {
         require Color::ANSI::Util;
         require Term::Detect::Software;
 
         my $use_color = $ENV{COLOR} // 1;
         my $terminfo = Term::Detect::Software::detect_terminal_cached();
         $use_color = 0 if !$terminfo->{color_depth};
         my $colorize = sub {
             my ($color, $str) = @_;
             if ($use_color) {
                 if (ref($color) eq 'ARRAY') {
                     (defined($color->[0]) ?
                          Color::ANSI::Util::ansifg($color->[0]):"").
                                (defined($color->[1]) ?
                                     Color::ANSI::Util::ansibg($color->[1]):"").
                                           $str . "\e[0m";
                 } else {
                     Color::ANSI::Util::ansifg($color) . $str . "\e[0m";
                 }
             } else {
                 $str;
             }
         };
 
         my $res = shift;
         my $out = $colorize->("cc0000", "ERROR $res->[0]") .
             ($res->[1] ? ": $res->[1]" : "");
         $out =~ s/\n+\z//;
         my $clog; $clog = $res->[3]{logs}[0]
             if $res->[3] && $res->[3]{logs};
         if ($clog->{file} && $clog->{line}) {
             $out .= " (at ".$colorize->('3399cc', $clog->{file}).
                 " line ".$colorize->('3399cc', $clog->{line}).")";
         }
         $out .= "\n";
         if ($clog->{stack_trace} && $INC{"Carp/Always.pm"} &&
                 !$stack_trace_printed) {
             require Data::Dump::OneLine;
             my $i;
             for my $c (@{ $clog->{stack_trace} }) {
                 next unless $i++; 
                 my $args;
                 if (!$c->[4]) {
                     $args = "()";
                 } elsif (!ref($c->[4])) {
                     $args = "(...)";
                 } else {
 
 
 
                     $args = Data::Dump::OneLine::dump1(
                         map {defined($_) ? "$_":$_} @{ $c->[4] });
                     $args = "($args)" if @{$c->[4]} == 1;
                 }
                 $out .= "    $c->[3]${args} called at $c->[1] line $c->[2]\n";
             }
             $stack_trace_printed++;
         }
         $out;
     };
 
     if (!defined($res->[2])) {
         my $out = $res->[0] =~ /\A(?:2..|304)\z/ ? "" : $print_err->($res);
         my $max = 30;
         my $i = 0;
         my $prev = $res;
         while (1) {
             if ($i > $max) {
                 $out .= "  Previous error list too deep, stopping here\n";
                 last;
             }
             last unless $prev = $prev->[3]{prev};
             last unless ref($prev) eq 'ARRAY';
             $out .= "  " . $print_err->($prev);
             $i++;
         }
         return $out;
     }
     my ($r, $opts);
     if ($res->[0] =~ /\A2../) {
         $r = $res->[2];
         my $rfo = $res->[3]{format_options} // {};
         if ($rfo->{$format}) {
             $opts = $rfo->{$format};
         } elsif ($rfo->{any}) {
             $opts = $rfo->{any};
         }
     } else {
         $r = $res;
     }
     $opts //= {};
     if ($format eq 'text') {
         return Data::Format::Pretty::format_pretty(
             $r, {%$opts, module=>'Console'});
     }
     if ($format eq 'text-simple') {
         return Data::Format::Pretty::format_pretty(
             $r, {%$opts, module=>'SimpleText'});
     }
     if ($format eq 'text-pretty') {
         return Data::Format::Pretty::format_pretty(
             $r, {%$opts, module=>'Text'});
     }
 };
 
 our %Formats = (
     yaml          => ['YAML', 'text/yaml', {circular=>0}],
     json          => ['CompactJSON', 'application/json', {circular=>0}],
     'json-pretty' => ['JSON', 'application/json', {circular=>0}],
     text          => [$format_text, 'text/plain', {circular=>0}],
     'text-simple' => [$format_text, 'text/plain', {circular=>0}],
     'text-pretty' => [$format_text, 'text/plain', {circular=>0}],
     'perl'        => ['Perl', 'text/x-perl', {circular=>1}],
     'phpserialization' => ['PHPSerialization', 'application/vnd.php.serialized', {circular=>0}],
     'ruby'        => ['Ruby', 'application/x-ruby', {circular=>1}],
 );
 
 sub format {
     require Data::Format::Pretty;
 
     my ($res, $format, $is_naked) = @_;
 
     my $fmtinfo = $Formats{$format} or return undef;
     my $formatter = $fmtinfo->[0];
 
     state $cleanser;
     if ($Enable_Cleansing && !$fmtinfo->[2]{circular}) {
         if (!$cleanser) {
             require Data::Clean::JSON;
             $cleanser = Data::Clean::JSON->get_cleanser;
         }
         $res = $cleanser->clone_and_clean($res);
     }
 
     my $deco = $Enable_Decoration;
 
     if (ref($formatter) eq 'CODE') {
         return $formatter->($format, $res);
     } else {
         my %o;
         $o{color} = 0 if !$deco && $format =~ /json|yaml|perl/;
         my $data = $is_naked ? $res->[2] : $res;
         return Data::Format::Pretty::format_pretty(
             $data, {%o, module=>$formatter});
     }
 }
 
 1;
 
 __END__
 
### Perinci/Result/Format/Lite.pm ###
 package Perinci::Result::Format::Lite;
 
 our $DATE = '2015-09-30'; 
 our $VERSION = '0.06'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use List::Util qw(first);
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(format);
 
 sub firstidx (&@) {
     my $f = shift;
     foreach my $i ( 0 .. $#_ )
         {
             local *_ = \$_[$i];
             return $i if $f->();
         }
     return -1;
 }
 
 sub _json {
     state $json = do {
         if    (eval { require JSON::XS; 1 })   { JSON::XS->new->canonical(1)->allow_nonref }
         elsif (eval { require JSON::Tiny::Subclassable; 1 }) { JSON::Tiny::Subclassable->new }
         elsif (eval { require JSON::PP; 1 })   { JSON::PP->new->canonical(1)->allow_nonref }
         else { die "Can't find any JSON module" }
     };
     $json;
 };
 
 sub __cleanse {
     state $cleanser = do {
         eval { require Data::Clean::JSON; 1 };
         if ($@) {
             undef;
         } else {
             Data::Clean::JSON->get_cleanser;
         }
     };
     if ($cleanser) {
         $cleanser->clean_in_place($_[0]);
     } else {
         $_[0];
     }
 }
 
 sub __gen_table {
     my ($data, $header_row, $resmeta, $is_pretty) = @_;
 
     $resmeta //= {};
 
     my @columns;
     if ($header_row) {
         @columns = @{$data->[0]};
     } else {
         @columns = map {"col$_"} 0..@{$data->[0]}-1;
     }
 
     my $column_orders; 
   SET_COLUMN_ORDERS: {
 
         my $tcos;
         if ($ENV{FORMAT_PRETTY_TABLE_COLUMN_ORDERS}) {
             $tcos = _json->encode($ENV{FORMAT_PRETTY_TABLE_COLUMN_ORDERS});
         } elsif (my $rfos = ($resmeta->{'cmdline.format_options'} //
                                  $resmeta->{format_options})) {
             my $rfo = $rfos->{'text-pretty'} // $rfos->{text} // $rfos->{any};
             if ($rfo) {
                 $tcos = $rfo->{table_column_orders};
             }
         }
         if ($tcos) {
           COLS:
             for my $cols (@$tcos) {
                 for my $col (@$cols) {
                     next COLS unless first {$_ eq $col} @columns;
                 }
                 $column_orders = $cols;
                 last SET_COLUMN_ORDERS;
             }
         }
 
         $column_orders = $resmeta->{'table.fields'};
     }
 
     if ($column_orders) {
         my @map0 = sort {
             my $idx_a = firstidx(sub {$_ eq $a->[1]},
                                                   @$column_orders) // 9999;
             my $idx_b = firstidx(sub {$_ eq $b->[1]},
                                                   @$column_orders) // 9999;
             $idx_a <=> $idx_b || $a->[1] cmp $b->[1];
         } map {[$_, $columns[$_]]} 0..@columns-1;
         my @map;
         for (0..@map0-1) {
             $map[$_] = $map0[$_][0];
         }
         my $newdata = [];
         for my $row (@$data) {
             my @newrow;
             for (0..@map-1) { $newrow[$_] = $row->[$map[$_]] }
             push @$newdata, \@newrow;
         }
         $data = $newdata;
     }
 
     if ($is_pretty) {
         require Text::Table::Tiny;
         Text::Table::Tiny::table(rows=>$data, header_row=>$header_row) . "\n";
     } else {
         no warnings 'uninitialized';
         shift @$data if $header_row;
         join("", map {join("\t", @$_)."\n"} @$data);
     }
 }
 
 sub format {
     my ($res, $format, $is_naked, $cleanse) = @_;
 
     if ($format =~ /\Atext(-simple|-pretty)?\z/) {
         my $is_pretty = $format eq 'text-pretty' ? 1 :
             $format eq 'text-simple' ? 0 : (-t STDOUT);
         no warnings 'uninitialized';
         if ($res->[0] !~ /^(2|304)/) {
             my $fres = "ERROR $res->[0]: $res->[1]";
             if (my $prev = $res->[3]{prev}) {
                 $fres .= " ($prev->[0]: $prev->[1])";
             }
             return "$fres\n";
         } elsif ($res->[3] && $res->[3]{"x.hint.result_binary"}) {
             return $res->[2];
         } else {
             require Data::Check::Structure;
             my $data = $res->[2];
             my $max = 5;
             if (!ref($data)) {
                 $data //= "";
                 $data .= "\n" unless !length($data) || $data =~ /\n\z/;
                 return $data;
             } elsif (ref($data) eq 'ARRAY' && !@$data) {
                 return "";
             } elsif (Data::Check::Structure::is_aos($data, {max=>$max})) {
                 return join("", map {"$_\n"} @$data);
             } elsif (Data::Check::Structure::is_aoaos($data, {max=>$max})) {
                 return __gen_table($data, 0, $res->[3], $is_pretty);
             } elsif (Data::Check::Structure::is_hos($data, {max=>$max})) {
                 $data = [map {[$_, $data->{$_}]} sort keys %$data];
                 unshift @$data, ["key", "value"];
                 return __gen_table($data, 1, $res->[3], $is_pretty);
             } elsif (Data::Check::Structure::is_aohos($data, {max=>$max})) {
                 my %fieldnames;
                 for my $row (@$data) {
                     $fieldnames{$_}++ for keys %$row;
                 }
                 my @fieldnames = sort keys %fieldnames;
                 my $newdata = [];
                 for my $row (@$data) {
                     push @$newdata, [map {$row->{$_}} @fieldnames];
                 }
                 unshift @$newdata, \@fieldnames;
                 return __gen_table($newdata, 1, $res->[3], $is_pretty);
             } else {
                 $format = 'json-pretty';
             }
         }
     }
 
     $res = $res->[2] if $is_naked;
 
     warn "Unknown format '$format', fallback to json-pretty"
         unless $format =~ /\Ajson(-pretty)?\z/;
     __cleanse($res) if ($cleanse//1);
     if ($format eq 'json') {
         return _json->encode($res) . "\n";
     } else {
         _json->pretty(1);
         return _json->encode($res);
     }
 }
 
 1;
 
 __END__
 
### Perinci/Sub/CoerceArgs.pm ###
 package Perinci::Sub::CoerceArgs;
 
 our $DATE = '2015-10-22'; 
 our $VERSION = '0.13'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Scalar::Util qw(blessed looks_like_number);
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        coerce_args
                );
 
 our %SPEC;
 
 
 sub _coerce_to_datetime {
     my ($args, $arg_name) = @_;
 
     my $val = $args->{$arg_name};
 
     if ($val =~ /\A\d{8,}\z/) {
         require DateTime;
         $args->{$arg_name} = DateTime->from_epoch(
             epoch => $val,
             time_zone => $ENV{TZ} // "UTC",
         );
         return [200];
     } elsif ($val =~ m!\A
                        (\d{4})[/-](\d{1,2})[/-](\d{1,2})
                        (?:[ Tt](\d{1,2}):(\d{1,2}):(\d{1,2}))?
                        \z!x) {
         require DateTime;
         $args->{$arg_name} = DateTime->new(
             year => $1, month => $2, day => $3,
             hour => $4 // 0,
             minute => $4 // 0,
             second => $4 // 0,
             time_zone => $ENV{TZ} // "UTC",
         );
         return [200];
     } elsif (blessed($val)) {
         if ($val->isa("DateTime")) {
             return [200];
         } elsif ($val->isa("Time::Moment")) {
             require DateTime;
             my $tz = sprintf("%s%04d",
                              $val->offset < 0 ? "-":"+",
                              abs($val->offset/60*100));
             $args->{$arg_name} = DateTime->from_epoch(
                 epoch => $val->epoch,
                 time_zone => $tz,
             );
             return [200];
         }
     }
 
     return [400, "Can't coerce '$arg_name' to DateTime object: " .
                 "'$args->{$arg_name}'"];
 }
 
 sub _coerce_to_time_moment {
     my ($args, $arg_name) = @_;
 
     my $val = $args->{$arg_name};
 
     if ($val =~ /\A\d{8,}\z/) {
         require Time::Moment;
         $args->{$arg_name} = Time::Moment->from_epoch($val);
         return [200];
     } elsif ($val =~ m!\A
                        (\d{4})[/-](\d{1,2})[/-](\d{1,2})
                        (?:[ Tt](\d{1,2}):(\d{1,2}):(\d{1,2}))?
                        \z!x) {
         require Time::Moment;
         $args->{$arg_name} = Time::Moment->new(
             year => $1, month => $2, day => $3,
             hour => $4 // 0,
             minute => $4 // 0,
             second => $4 // 0,
         );
         return [200];
     } elsif (blessed($val)) {
         if ($val->isa("Time::Moment")) {
             return [200];
         } elsif ($val->isa("DateTime")) {
             require Time::Moment;
             $args->{$arg_name} = Time::Moment->from_object($val);
             return [200];
         }
     }
 
     return [400, "Can't coerce '$arg_name' to Time::Moment object: " .
                 "'$args->{$arg_name}'"];
 }
 
 sub _coerce_to_epoch {
     my ($args, $arg_name) = @_;
 
     my $val = $args->{$arg_name};
 
     if (looks_like_number($val)) {
         return [200];
     } elsif ($val =~ m!\A
                        (\d{4})[/-](\d{1,2})[/-](\d{1,2})
                        (?:[ Tt](\d{1,2}):(\d{1,2}):(\d{1,2}))?
                        \z!x) {
         require DateTime;
         $args->{$arg_name} = DateTime->new(
             year => $1, month => $2, day => $3,
             hour => $4 // 0,
             minute => $4 // 0,
             second => $4 // 0,
             time_zone => $ENV{TZ} // "UTC",
         )->epoch;
         return [200];
     } elsif (blessed($val)) {
         if ($val->isa("DateTime")) {
             $args->{$arg_name} = $val->epoch;
             return [200];
         } elsif ($val->isa("Time::Moment")) {
             $args->{$arg_name} = $val->epoch;
             return [200];
         }
     }
 
     return [400, "Can't coerce epoch " .
                 "'$arg_name' from '$args->{$arg_name}'"];
 }
 
 sub _coerce_to_datetime_duration {
     my ($args, $arg_name) = @_;
 
     my $val = $args->{$arg_name};
 
     my $d;
 
     if ($val =~ /\A\+?\d+(?:\.\d*)?\z/) {
         require DateTime::Duration;
         my $days = int($val/86400);
         my $secs = $val - $days*86400;
         $args->{$arg_name} = DateTime::Duration->new(
             days    => $days,
             seconds => $secs,
         );
         return [200];
     } elsif ($val =~ /\AP
                  (?:([0-9]+(?:\.[0-9]+)?)Y)?
                  (?:([0-9]+(?:\.[0-9]+)?)M)?
                  (?:([0-9]+(?:\.[0-9]+)?)W)?
                  (?:([0-9]+(?:\.[0-9]+)?)D)?
                  (?: T
                      (?:([0-9]+(?:\.[0-9]+)?)H)?
                      (?:([0-9]+(?:\.[0-9]+)?)M)?
                      (?:([0-9]+(?:\.[0-9]+)?)S)?
                  )?\z/x) {
         require DateTime::Duration;
         $args->{$arg_name} = DateTime::Duration->new(
             years   => $1 || 0,
             months  => $2 || 0,
             weeks   => $3 || 0,
             days    => $4 || 0,
             hours   => $5 || 0,
             minutes => $6 || 0,
             seconds => $7 || 0,
         );
         return [200];
     } elsif (blessed($val)) {
         if ($val->isa("DateTime::Duration")) {
             return [200];
         }
     } elsif (eval { require Time::Duration::Parse::AsHash; $d = Time::Duration::Parse::AsHash::parse_duration($val) } && !$@) {
         require DateTime::Duration;
         $args->{$arg_name} = DateTime::Duration->new(
             years   => $d->{years}   || 0,
             months  => $d->{months}  || 0,
             weeks   => $d->{weeks}   || 0,
             days    => $d->{days}    || 0,
             hours   => $d->{hours}   || 0,
             minutes => $d->{minutes} || 0,
             seconds => $d->{seconds} || 0,
         );
         return [200];
     }
 
     return [400, "Can't coerce '$arg_name' to DateTime::Duration object: " .
                 "'$args->{$arg_name}'"];
 }
 
 sub _coerce_to_secs {
     my ($args, $arg_name) = @_;
 
     my $val = $args->{$arg_name};
 
     my $d;
 
     if ($val =~ /\A\+?\d+(?:\.\d*)?\z/) {
         return [200];
     } elsif ($val =~ /\AP
                  (?:([0-9]+(?:\.[0-9]+)?)Y)?
                  (?:([0-9]+(?:\.[0-9]+)?)M)?
                  (?:([0-9]+(?:\.[0-9]+)?)W)?
                  (?:([0-9]+(?:\.[0-9]+)?)D)?
                  (?: T
                      (?:([0-9]+(?:\.[0-9]+)?)H)?
                      (?:([0-9]+(?:\.[0-9]+)?)M)?
                      (?:([0-9]+(?:\.[0-9]+)?)S)?
                  )?\z/x) {
         $args->{$arg_name} =
             (($1//0)*365 + ($2 // 0)*30 + ($3 // 0)*7 + ($4 // 0)) * 86400 +
             ($5 // 0)*3600 + ($6 // 0)*60 + ($7 // 0);
         return [200];
     } elsif (blessed($val)) {
         if ($val->isa("DateTime::Duration")) {
             my ($y, $mon, $d, $min, $s) = $val->in_units(
                 "years", "months", "days", "minutes", "seconds");
             $args->{$arg_name} =
                 ($y*365 + $mon*30 + $d) * 86400 +
                 $min*60 + $s;
             return [200];
         }
     } elsif (eval { require Time::Duration::Parse::AsHash; $d = Time::Duration::Parse::AsHash::parse_duration($val) } && !$@) {
         $args->{$arg_name} =
             ($d->{years}   // 0) * 365*86400 +
             ($d->{months}  // 0) *  30*86400 +
             ($d->{weeks}   // 0) *   7*86400 +
             ($d->{days}    // 0) *     86400 +
             ($d->{hours}   // 0) *      3600 +
             ($d->{minutes} // 0) *        60 +
             ($d->{seconds} // 0);
         return [200];
     }
 
     return [400, "Can't coerce '$arg_name' to seconds: " .
                 "'$args->{$arg_name}'"];
 }
 
 $SPEC{coerce_args} = {
     v           => 1.1,
     summary     => 'Coerce arguments',
     description => <<'_',
 
 This routine can be used when function arguments are retrieved from strings,
 like from command-line arguments in CLI application (see
 `Perinci::CmdLine::Lite` or `Perinci::CmdLine::Classic`) or from web form
 variables in web application (see `Borang`). For convenience, object or complex
 data structure can be converted from string (e.g. `DateTime` object from strings
 like `2015-03-27` or epoch integer). And filters can be applied to
 clean/preprocess the string (e.g. remove leading/trailing blanks) beforehand.
 
 _
     args => {
         meta => {
             summary => 'Rinci function metadata',
             schema  => 'hash*',
             req     => 1,
         },
         meta_is_normalized => {
             schema => 'bool*',
         },
         args => {
             summary => 'Reference to hash which store the arguments',
             schema  => 'hash*',
         },
     },
 };
 sub coerce_args {
     my %fargs = @_;
 
     my $meta = $fargs{meta} or return [400, "Please specify meta"];
     unless ($fargs{meta_is_normalized}) {
         require Perinci::Sub::Normalize;
         $meta = Perinci::Sub::Normalize::normalize_function_metadata($meta);
     }
     my $args = $fargs{args};
 
     for my $arg_name (keys %$args) {
         my $val = $args->{$arg_name};
         next unless defined($val);
         my $arg_spec = $meta->{args}{$arg_name};
         next unless $arg_spec;
 
         if (my $filters = $arg_spec->{filters}) {
             for my $filter (@$filters) {
                 if (ref($filter) eq 'CODE') {
                     $val = $filter->($val);
                 } elsif ($filter eq 'trim') {
                     $val =~ s/\A\s+//s;
                     $val =~ s/\s+\z//s;
                 } elsif ($filter eq 'ltrim') {
                     $val =~ s/\s+\z//s;
                 } elsif ($filter eq 'rtrim') {
                     $val =~ s/\A\s+//s;
                 } else {
                     return [400, "Unknown filter '$filter' ".
                                 "for argument '$arg_name'"];
                 }
             }
             $args->{$arg_name} = $val if @$filters;
         }
 
         if (my $schema = $arg_spec->{schema}) {
             my $coerce_to = $arg_spec->{'x.perl.coerce_to'} // '';
             if ($schema->[0] eq 'obj') {
                 my $class = $schema->[1]{isa} // '';
                 if ($class eq 'DateTime') {
                     my $coerce_res = _coerce_to_datetime($args, $arg_name);
                     return $coerce_res unless $coerce_res->[0] == 200;
                 } elsif ($class eq 'DateTime::Duration') {
                     my $coerce_res = _coerce_to_datetime_duration($args, $arg_name);
                     return $coerce_res unless $coerce_res->[0] == 200;
                 } elsif ($class eq 'Time::Moment') {
                     my $coerce_res = _coerce_to_time_moment($args, $arg_name);
                     return $coerce_res unless $coerce_res->[0] == 200;
                 }
             } elsif ($schema->[0] eq 'date') {
                 if ($coerce_to eq 'DateTime') {
                     my $coerce_res = _coerce_to_datetime($args, $arg_name);
                     return $coerce_res unless $coerce_res->[0] == 200;
                 } elsif ($coerce_to eq 'Time::Moment') {
                     my $coerce_res = _coerce_to_time_moment($args, $arg_name);
                     return $coerce_res unless $coerce_res->[0] == 200;
                 } elsif ($coerce_to eq 'int(epoch)') {
                     my $coerce_res = _coerce_to_epoch($args, $arg_name);
                     return $coerce_res unless $coerce_res->[0] == 200;
                 }
             } elsif ($schema->[0] eq 'duration') {
                 if ($coerce_to eq 'DateTime::Duration') {
                     my $coerce_res = _coerce_to_datetime_duration($args, $arg_name);
                     return $coerce_res unless $coerce_res->[0] == 200;
                 } elsif ($coerce_to eq 'int(secs)') {
                     my $coerce_res = _coerce_to_secs($args, $arg_name);
                     return $coerce_res unless $coerce_res->[0] == 200;
                 }
             }
         } 
     }
 
     [200, "OK", $args];
 }
 
 1;
 
 __END__
 
### Perinci/Sub/Complete.pm ###
 package Perinci::Sub::Complete;
 
 our $DATE = '2015-09-09'; 
 our $VERSION = '0.82'; 
 
 use 5.010001;
 use strict;
 use warnings;
 use Log::Any::IfLOG '$log';
 
 use Complete::Util qw(hashify_answer complete_array_elem combine_answers);
 use Complete::Setting;
 use Perinci::Sub::Util qw(gen_modified_sub);
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(
                        complete_from_schema
                        complete_arg_val
                        complete_arg_elem
                        complete_cli_arg
                );
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'Complete command-line argument using Rinci metadata',
 };
 
 my %common_args_riap = (
     riap_client => {
         summary => 'Optional, to perform complete_arg_val to the server',
         schema  => 'obj*',
         description => <<'_',
 
 When the argument spec in the Rinci metadata contains `completion` key, this
 means there is custom completion code for that argument. However, if retrieved
 from a remote server, sometimes the `completion` key no longer contains the code
 (it has been cleansed into a string). Moreover, the completion code needs to run
 on the server.
 
 If supplied this argument and te `riap_server_url` argument, the function will
 try to request to the server (via Riap request `complete_arg_val`). Otherwise,
 the function will just give up/decline completing.
 
 _
         },
     riap_server_url => {
         summary => 'Optional, to perform complete_arg_val to the server',
         schema  => 'str*',
         description => <<'_',
 
 See the `riap_client` argument.
 
 _
     },
     riap_uri => {
         summary => 'Optional, to perform complete_arg_val to the server',
         schema  => 'str*',
         description => <<'_',
 
 See the `riap_client` argument.
 
 _
     },
 );
 
 $SPEC{complete_from_schema} = {
     v => 1.1,
     summary => 'Complete a value from schema',
     description => <<'_',
 
 Employ some heuristics to complete a value from Sah schema. For example, if
 schema is `[str => in => [qw/new open resolved rejected/]]`, then we can
 complete from the `in` clause. Or for something like `[int => between => [1,
 20]]` we can complete using values from 1 to 20.
 
 _
     args => {
         schema => {
             summary => 'Must be normalized',
             req => 1,
         },
         word => {
             schema => [str => default => ''],
             req => 1,
         },
         ci => {
             schema => 'bool',
         },
     },
 };
 sub complete_from_schema {
     my %args = @_;
     my $sch  = $args{schema}; 
     my $word = $args{word} // "";
     my $ci   = $args{ci} // $Complete::Setting::OPT_CI;
 
     my $fres;
     $log->tracef("[comp][periscomp] entering complete_from_schema, word=<%s>, schema=%s", $word, $sch);
 
     my ($type, $cs) = @{$sch};
 
     my $static;
     my $words;
     eval {
         if ($cs->{is} && !ref($cs->{is})) {
             $log->tracef("[comp][periscomp] adding completion from 'is' clause");
             push @$words, $cs->{is};
             $static++;
             return; 
         }
         if ($cs->{in}) {
             $log->tracef("[comp][periscomp] adding completion from 'in' clause");
             push @$words, grep {!ref($_)} @{ $cs->{in} };
             $static++;
             return; 
         }
         if ($type eq 'any') {
             require Data::Sah::Normalize;
             if ($cs->{of} && @{ $cs->{of} }) {
                 $fres = combine_answers(
                     grep { defined } map {
                         complete_from_schema(
                             schema=>Data::Sah::Normalize::normalize_schema($_),
                             word => $word,
                             ci => $ci,
                         )
                     } @{ $cs->{of} }
                 );
                 goto RETURN_RES; 
             }
         }
         if ($type eq 'bool') {
             $log->tracef("[comp][periscomp] adding completion from possible values of bool");
             push @$words, 0, 1;
             $static++;
             return; 
         }
         if ($type eq 'int') {
             my $limit = 100;
             if ($cs->{between} &&
                     $cs->{between}[0] - $cs->{between}[0] <= $limit) {
                 $log->tracef("[comp][periscomp] adding completion from 'between' clause");
                 push @$words, $cs->{between}[0] .. $cs->{between}[1];
                 $static++;
             } elsif ($cs->{xbetween} &&
                          $cs->{xbetween}[0] - $cs->{xbetween}[0] <= $limit) {
                 $log->tracef("[comp][periscomp] adding completion from 'xbetween' clause");
                 push @$words, $cs->{xbetween}[0]+1 .. $cs->{xbetween}[1]-1;
                 $static++;
             } elsif (defined($cs->{min}) && defined($cs->{max}) &&
                          $cs->{max}-$cs->{min} <= $limit) {
                 $log->tracef("[comp][periscomp] adding completion from 'min' & 'max' clauses");
                 push @$words, $cs->{min} .. $cs->{max};
                 $static++;
             } elsif (defined($cs->{min}) && defined($cs->{xmax}) &&
                          $cs->{xmax}-$cs->{min} <= $limit) {
                 $log->tracef("[comp][periscomp] adding completion from 'min' & 'xmax' clauses");
                 push @$words, $cs->{min} .. $cs->{xmax}-1;
                 $static++;
             } elsif (defined($cs->{xmin}) && defined($cs->{max}) &&
                          $cs->{max}-$cs->{xmin} <= $limit) {
                 $log->tracef("[comp][periscomp] adding completion from 'xmin' & 'max' clauses");
                 push @$words, $cs->{xmin}+1 .. $cs->{max};
                 $static++;
             } elsif (defined($cs->{xmin}) && defined($cs->{xmax}) &&
                          $cs->{xmax}-$cs->{xmin} <= $limit) {
                 $log->tracef("[comp][periscomp] adding completion from 'xmin' & 'xmax' clauses");
                 push @$words, $cs->{xmin}+1 .. $cs->{xmax}-1;
                 $static++;
             } elsif (length($word) && $word !~ /\A-?\d*\z/) {
                 $log->tracef("[comp][periscomp] word not an int");
                 $words = [];
             } else {
                 $words = [];
                 for my $sign ("", "-") {
                     for ("", 0..9) {
                         my $i = $sign . $word . $_;
                         next unless length $i;
                         next unless $i =~ /\A-?\d+\z/;
                         next if $i eq '-0';
                         next if $i =~ /\A-?0\d/;
                         next if $cs->{between} &&
                             ($i < $cs->{between}[0] ||
                                  $i > $cs->{between}[1]);
                         next if $cs->{xbetween} &&
                             ($i <= $cs->{xbetween}[0] ||
                                  $i >= $cs->{xbetween}[1]);
                         next if defined($cs->{min} ) && $i <  $cs->{min};
                         next if defined($cs->{xmin}) && $i <= $cs->{xmin};
                         next if defined($cs->{max} ) && $i >  $cs->{max};
                         next if defined($cs->{xmin}) && $i >= $cs->{xmax};
                         push @$words, $i;
                     }
                 }
                 $words = [sort @$words];
             }
             return; 
         }
         if ($type eq 'float') {
             if (length($word) && $word !~ /\A-?\d*(\.\d*)?\z/) {
                 $log->tracef("[comp][periscomp] word not a float");
                 $words = [];
             } else {
                 $words = [];
                 for my $sig ("", "-") {
                     for ("", 0..9,
                          ".0",".1",".2",".3",".4",".5",".6",".7",".8",".9") {
                         my $f = $sig . $word . $_;
                         next unless length $f;
                         next unless $f =~ /\A-?\d+(\.\d+)?\z/;
                         next if $f eq '-0';
                         next if $f =~ /\A-?0\d\z/;
                         next if $cs->{between} &&
                             ($f < $cs->{between}[0] ||
                                  $f > $cs->{between}[1]);
                         next if $cs->{xbetween} &&
                             ($f <= $cs->{xbetween}[0] ||
                                  $f >= $cs->{xbetween}[1]);
                         next if defined($cs->{min} ) && $f <  $cs->{min};
                         next if defined($cs->{xmin}) && $f <= $cs->{xmin};
                         next if defined($cs->{max} ) && $f >  $cs->{max};
                         next if defined($cs->{xmin}) && $f >= $cs->{xmax};
                         push @$words, $f;
                     }
                 }
             }
             return; 
         }
     }; 
 
     $log->tracef("[periscomp] complete_from_schema died: %s", $@) if $@;
 
     goto RETURN_RES unless $words;
     $fres = hashify_answer(
         complete_array_elem(array=>$words, word=>$word, ci=>$ci),
         {static=>$static && $word eq '' ? 1:0},
     );
 
   RETURN_RES:
     $log->tracef("[comp][periscomp] leaving complete_from_schema, result=%s", $fres);
     $fres;
 }
 
 $SPEC{complete_arg_val} = {
     v => 1.1,
     summary => 'Given argument name and function metadata, complete value',
     description => <<'_',
 
 Will attempt to complete using the completion routine specified in the argument
 specification (the `completion` property, or in the case of `complete_arg_elem`
 function, the `element_completion` property), or if that is not specified, from
 argument's schema using `complete_from_schema`.
 
 Completion routine will get `%args`, with the following keys:
 
 * `word` (str, the word to be completed)
 * `ci` (bool, whether string matching should be case-insensitive)
 * `arg` (str, the argument name which value is currently being completed)
 * `index (int, only for the `complete_arg_elem` function, the index in the
    argument array that is currently being completed, starts from 0)
 * `args` (hash, the argument hash to the function, so far)
 
 as well as extra keys from `extras` (but these won't overwrite the above
 standard keys).
 
 Completion routine should return a completion answer structure (described in
 `Complete`) which is either a hash or an array. The simplest form of answer is
 just to return an array of strings. Completion routine can also return undef to
 express declination.
 
 _
     args => {
         meta => {
             summary => 'Rinci function metadata, must be normalized',
             schema => 'hash*',
             req => 1,
         },
         arg => {
             summary => 'Argument name',
             schema => 'str*',
             req => 1,
         },
         word => {
             summary => 'Word to be completed',
             schema => ['str*', default => ''],
         },
         ci => {
             summary => 'Whether to be case-insensitive',
             schema => ['bool*'],
         },
         args => {
             summary => 'Collected arguments so far, '.
                 'will be passed to completion routines',
             schema  => 'hash',
         },
         extras => {
             summary => 'Add extra arguments to completion routine',
             schema  => 'hash',
             description => <<'_',
 
 The keys from this `extras` hash will be merged into the final `%args` passed to
 completion routines. Note that standard keys like `word`, `cword`, `ci`, and so
 on as described in the function description will not be overwritten by this.
 
 _
         },
 
         %common_args_riap,
     },
     result_naked => 1,
     result => {
         schema => 'array', 
     },
 };
 sub complete_arg_val {
     my %args = @_;
 
     $log->tracef("[comp][periscomp] entering complete_arg_val, arg=<%s>", $args{arg});
     my $fres;
 
     my $extras = $args{extras} // {};
 
     my $meta = $args{meta} or do {
         $log->tracef("[comp][periscomp] meta is not supplied, declining");
         goto RETURN_RES;
     };
     my $arg  = $args{arg} or do {
         $log->tracef("[comp][periscomp] arg is not supplied, declining");
         goto RETURN_RES;
     };
     my $ci   = $args{ci} // $Complete::Setting::OPT_CI;
     my $word = $args{word} // '';
 
 
     my $args_prop = $meta->{args} // {};
     my $arg_spec = $args_prop->{$arg} or do {
         $log->tracef("[comp][periscomp] arg '$arg' is not specified in meta, declining");
         goto RETURN_RES;
     };
 
     my $static;
     eval { 
 
         my $comp;
       GET_COMP_ROUTINE:
         {
             $comp = $arg_spec->{completion};
             if ($comp) {
                 $log->tracef("[comp][periscomp] using arg completion routine from 'completion' property");
                 last GET_COMP_ROUTINE;
             }
             my $xcomp = $arg_spec->{'x.completion'};
             if ($xcomp) {
                 require Module::Path::More;
                 my $mod = "Perinci::Sub::XCompletion::$xcomp->[0]";
                 if (Module::Path::More::module_path(module=>$mod)) {
                     $log->tracef("[comp][periscomp] loading module %s ...", $mod);
                     my $mod_pm = $mod; $mod_pm =~ s!::!/!g; $mod_pm .= ".pm";
                     require $mod_pm;
                     my $fref = \&{"$mod\::gen_completion"};
                     $comp = $fref->(%{ $xcomp->[1] });
                 }
                 if ($comp) {
                     $log->tracef("[comp][periscomp] using arg completion routine from 'x.completion' attribute");
                     last GET_COMP_ROUTINE;
                 }
             }
             my $ent = $arg_spec->{'x.schema.entity'};
             if ($ent) {
                 require Module::Path::More;
                 my $mod = "Perinci::Sub::ArgEntity::$ent";
                 if (Module::Path::More::module_path(module=>$mod)) {
                     $log->tracef("[comp][periscomp] loading module %s ...", $mod);
                     my $mod_pm = $mod; $mod_pm =~ s!::!/!g; $mod_pm .= ".pm";
                     require $mod_pm;
                     if (defined &{"$mod\::complete_arg_val"}) {
                         $log->tracef("[comp][periscomp] using arg completion routine from complete_arg_val() from %s", $mod);
                         $comp = \&{"$mod\::complete_arg_val"};
                         last GET_COMP_ROUTINE;
                     }
                 }
             }
         } 
 
         if ($comp) {
             if (ref($comp) eq 'CODE') {
                 $log->tracef("[comp][periscomp] invoking arg completion routine");
                 $fres = $comp->(
                     %$extras,
                     word=>$word, ci=>$ci, arg=>$arg, args=>$args{args});
                 return; 
             } elsif (ref($comp) eq 'ARRAY') {
                 $log->tracef("[comp][periscomp] using array specified in arg completion routine: %s", $comp);
                 $fres = complete_array_elem(
                     array=>$comp, word=>$word, ci=>$ci);
                 $static++;
                 return; 
             }
 
             $log->tracef("[comp][periscomp] arg spec's 'completion' property is not a coderef or arrayref");
             if ($args{riap_client} && $args{riap_server_url}) {
                 $log->tracef("[comp][periscomp] trying to perform complete_arg_val request to Riap server");
                 my $res = $args{riap_client}->request(
                     complete_arg_val => $args{riap_server_url},
                     {(uri=>$args{riap_uri}) x !!defined($args{riap_uri}),
                      arg=>$arg, word=>$word, ci=>$ci},
                 );
                 if ($res->[0] != 200) {
                     $log->tracef("[comp][periscomp] Riap request failed (%s), declining", $res);
                     return; 
                 }
                 $fres = $res->[2];
                 return; 
             }
 
             $log->tracef("[comp][periscomp] declining");
             return; 
         }
 
         my $sch = $arg_spec->{schema};
         unless ($sch) {
             $log->tracef("[comp][periscomp] arg spec does not specify schema, declining");
             return; 
         };
 
 
         $fres = complete_from_schema(schema=>$sch, word=>$word, ci=>$ci);
     };
     $log->debug("[comp][periscomp] completion died: $@") if $@;
     unless ($fres) {
         $log->tracef("[comp][periscomp] no completion from metadata possible, declining");
         goto RETURN_RES;
     }
 
     $fres = hashify_answer($fres);
     $fres->{static} //= $static && $word eq '' ? 1:0;
   RETURN_RES:
     $log->tracef("[comp][periscomp] leaving complete_arg_val, result=%s", $fres);
     $fres;
 }
 
 gen_modified_sub(
     output_name  => 'complete_arg_elem',
     install_sub  => 0,
     base_name    => 'complete_arg_val',
     summary      => 'Given argument name and function metadata, '.
         'complete array element',
     add_args     => {
         index => {
             summary => 'Index of element to complete',
             schema  => [int => min => 0],
         },
     },
 );
 sub complete_arg_elem {
     require Data::Sah::Normalize;
 
     my %args = @_;
 
     my $fres;
 
     $log->tracef("[comp][periscomp] entering complete_arg_elem, arg=<%s>, index=<%d>",
                  $args{arg}, $args{index});
 
     my $extras = $args{extras} // {};
 
     my $ourextras = {arg=>$args{arg}, args=>$args{args}};
 
     my $meta = $args{meta} or do {
         $log->tracef("[comp][periscomp] meta is not supplied, declining");
         goto RETURN_RES;
     };
     my $arg  = $args{arg} or do {
         $log->tracef("[comp][periscomp] arg is not supplied, declining");
         goto RETURN_RES;
     };
     defined(my $index = $args{index}) or do {
         $log->tracef("[comp][periscomp] index is not supplied, declining");
         goto RETURN_RES;
     };
     my $ci   = $args{ci} // $Complete::Setting::OPT_CI;
     my $word = $args{word} // '';
 
 
     my $args_prop = $meta->{args} // {};
     my $arg_spec = $args_prop->{$arg} or do {
         $log->tracef("[comp][periscomp] arg '$arg' is not specified in meta, declining");
         goto RETURN_RES;
     };
 
     my $static;
     eval { 
 
         my $elcomp;
       GET_ELCOMP_ROUTINE:
         {
             $elcomp = $arg_spec->{element_completion};
             if ($elcomp) {
                 $log->tracef("[comp][periscomp] using arg element completion routine from 'element_completion' property");
                 last GET_ELCOMP_ROUTINE;
             }
             my $xelcomp = $arg_spec->{'x.element_completion'};
             if ($xelcomp) {
                require Module::Path::More;
                 my $mod = "Perinci::Sub::XCompletion::$xelcomp->[0]";
                 if (Module::Path::More::module_path(module=>$mod)) {
                     $log->tracef("[comp][periscomp] loading module %s ...", $mod);
                     my $mod_pm = $mod; $mod_pm =~ s!::!/!g; $mod_pm .= ".pm";
                     require $mod_pm;
                     my $fref = \&{"$mod\::gen_completion"};
                     $elcomp = $fref->(%{ $xelcomp->[1] });
                 }
                 if ($elcomp) {
                     $log->tracef("[comp][periscomp] using arg element completion routine from 'x.element_completion' attribute");
                     last GET_ELCOMP_ROUTINE;
                 }
             }
             my $ent = $arg_spec->{'x.schema.element_entity'};
             if ($ent) {
                 require Module::Path::More;
                 my $mod = "Perinci::Sub::ArgEntity::$ent";
                 if (Module::Path::More::module_path(module=>$mod)) {
                     $log->tracef("[comp][periscomp] loading module %s ...", $mod);
                     my $mod_pm = $mod; $mod_pm =~ s!::!/!g; $mod_pm .= ".pm";
                     require $mod_pm;
                     if (defined &{"$mod\::complete_arg_val"}) {
                         $log->tracef("[comp][periscomp] using arg element completion routine from complete_arg_val() from %s", $mod);
                         $elcomp = \&{"$mod\::complete_arg_val"};
                         last GET_ELCOMP_ROUTINE;
                     }
                 }
             }
         } 
 
         $ourextras->{index} = $index;
         if ($elcomp) {
             if (ref($elcomp) eq 'CODE') {
                 $log->tracef("[comp][periscomp] invoking arg element completion routine");
                 $fres = $elcomp->(
                     %$extras,
                     %$ourextras,
                     word=>$word, ci=>$ci);
                 return; 
             } elsif (ref($elcomp) eq 'ARRAY') {
                 $log->tracef("[comp][periscomp] using array specified in arg element completion routine: %s", $elcomp);
                 $fres = complete_array_elem(
                     array=>$elcomp, word=>$word, ci=>$ci);
                 $static = $word eq '';
             }
 
             $log->tracef("[comp][periscomp] arg spec's 'element_completion' property is not a coderef or ".
                              "arrayref");
             if ($args{riap_client} && $args{riap_server_url}) {
                 $log->tracef("[comp][periscomp] trying to perform complete_arg_elem request to Riap server");
                 my $res = $args{riap_client}->request(
                     complete_arg_elem => $args{riap_server_url},
                     {(uri=>$args{riap_uri}) x !!defined($args{riap_uri}),
                      arg=>$arg, args=>$args{args}, word=>$word, ci=>$ci,
                      index=>$index},
                 );
                 if ($res->[0] != 200) {
                     $log->tracef("[comp][periscomp] Riap request failed (%s), declining", $res);
                     return; 
                 }
                 $fres = $res->[2];
                 return; 
             }
 
             $log->tracef("[comp][periscomp] declining");
             return; 
         }
 
         my $sch = $arg_spec->{schema};
         unless ($sch) {
             $log->tracef("[comp][periscomp] arg spec does not specify schema, declining");
             return; 
         };
 
 
         my ($type, $cs) = @{ $sch };
         if ($type ne 'array') {
             $log->tracef("[comp][periscomp] can't complete element for non-array");
             return; 
         }
 
         unless ($cs->{of}) {
             $log->tracef("[comp][periscomp] schema does not specify 'of' clause, declining");
             return; 
         }
 
         my $elsch = Data::Sah::Normalize::normalize_schema($cs->{of});
 
         $fres = complete_from_schema(schema=>$elsch, word=>$word, ci=>$ci);
     };
     $log->debug("[comp][periscomp] completion died: $@") if $@;
     unless ($fres) {
         $log->tracef("[comp][periscomp] no completion from metadata possible, declining");
         goto RETURN_RES;
     }
 
     $fres = hashify_answer($fres);
     $fres->{static} //= $static && $word eq '' ? 1:0;
   RETURN_RES:
     $log->tracef("[comp][periscomp] leaving complete_arg_elem, result=%s", $fres);
     $fres;
 }
 
 $SPEC{complete_cli_arg} = {
     v => 1.1,
     summary => 'Complete command-line argument using Rinci function metadata',
     description => <<'_',
 
 This routine uses `Perinci::Sub::GetArgs::Argv` to generate `Getopt::Long`
 specification from arguments list in Rinci function metadata and common options.
 Then, it will use `Complete::Getopt::Long` to complete option names, option
 values, as well as arguments.
 
 _
     args => {
         meta => {
             summary => 'Rinci function metadata',
             schema => 'hash*',
             req => 1,
         },
         words => {
             summary => 'Command-line arguments',
             schema => ['array*' => {of=>'str*'}],
             req => 1,
         },
         cword => {
             summary => 'On which argument cursor is located (zero-based)',
             schema => 'int*',
             req => 1,
         },
         completion => {
             summary => 'Supply custom completion routine',
             description => <<'_',
 
 If supplied, instead of the default completion routine, this code will be called
 instead. Will receive all arguments that `Complete::Getopt::Long` will pass, and
 additionally:
 
 * `arg` (str, the name of function argument)
 * `args` (hash, the function arguments formed so far)
 * `index` (int, if completing argument element value)
 
 _
             schema => 'code*',
         },
         per_arg_json => {
             summary => 'Will be passed to Perinci::Sub::GetArgs::Argv',
             schema  => 'bool',
         },
         per_arg_yaml => {
             summary => 'Will be passed to Perinci::Sub::GetArgs::Argv',
             schema  => 'bool',
         },
         common_opts => {
             summary => 'Common options',
             description => <<'_',
 
 A hash where the values are hashes containing these keys: `getopt` (Getopt::Long
 option specification), `handler` (Getopt::Long handler). Will be passed to
 `get_args_from_argv()`. Example:
 
     {
         help => {
             getopt  => 'help|h|?',
             handler => sub { ... },
             summary => 'Display help and exit',
         },
         version => {
             getopt  => 'version|v',
             handler => sub { ... },
             summary => 'Display version and exit',
         },
     }
 
 _
             schema => ['hash*'],
         },
         extras => {
             summary => 'Add extra arguments to completion routine',
             schema  => 'hash',
             description => <<'_',
 
 The keys from this `extras` hash will be merged into the final `%args` passed to
 completion routines. Note that standard keys like `word`, `cword`, `ci`, and so
 on as described in the function description will not be overwritten by this.
 
 _
         },
         func_arg_starts_at => {
             schema  => 'int*',
             default => 0,
             description => <<'_',
 
 This is a (temporary?) workaround for Perinci::CmdLine. In an application with
 subcommands (e.g. `cmd --verbose subcmd arg0 arg1 ...`), then `words` will still
 contain the subcommand name. Positional function arguments then start at 1 not
 0. This option allows offsetting function arguments.
 
 _
         },
         %common_args_riap,
     },
     result_naked => 1,
     result => {
         schema => 'hash*',
         description => <<'_',
 
 You can use `format_completion` function in `Complete::Bash` module to format
 the result of this function for bash.
 
 _
     },
 };
 sub complete_cli_arg {
     require Complete::Getopt::Long;
     require Perinci::Sub::GetArgs::Argv;
 
     my %args   = @_;
     my $meta   = $args{meta} or die "Please specify meta";
     my $words  = $args{words} or die "Please specify words";
     my $cword  = $args{cword}; defined($cword) or die "Please specify cword";
     my $copts  = $args{common_opts} // {};
     my $comp   = $args{completion};
     my $extras = {
         %{ $args{extras} // {} },
         words => $args{words},
         cword => $args{cword},
     };
 
     my $fname = __PACKAGE__ . "::complete_cli_arg"; 
     my $fres;
 
     my $word   = $words->[$cword];
     my $args_prop = $meta->{args} // {};
 
     $log->tracef('[comp][periscomp] entering %s(), words=%s, cword=%d, word=<%s>',
                  $fname, $words, $cword, $word);
 
     my $genres = Perinci::Sub::GetArgs::Argv::gen_getopt_long_spec_from_meta(
         meta         => $meta,
         common_opts  => $copts,
         per_arg_json => $args{per_arg_json},
         per_arg_yaml => $args{per_arg_yaml},
         ignore_converted_code => 1,
     );
     die "Can't generate getopt spec from meta: $genres->[0] - $genres->[1]"
         unless $genres->[0] == 200;
     my $gospec = $genres->[2];
     my $specmeta = $genres->[3]{'func.specmeta'};
 
     my $gares = Perinci::Sub::GetArgs::Argv::get_args_from_argv(
         argv   => [@$words],
         meta   => $meta,
         strict => 0,
     );
 
     my $copts_by_ospec = {};
     for (keys %$copts) { $copts_by_ospec->{$copts->{$_}{getopt}}=$copts->{$_} }
 
     my $compgl_comp = sub {
         $log->tracef("[comp][periscomp] entering completion routine (that we supply to Complete::Getopt::Long)");
         my %cargs = @_;
         my $type  = $cargs{type};
         my $ospec = $cargs{ospec} // '';
         my $word  = $cargs{word};
         my $ci    = $cargs{ci} // $Complete::Setting::OPT_CI;
 
         my $fres;
 
         my %rargs = (
             riap_server_url => $args{riap_server_url},
             riap_uri        => $args{riap_uri},
             riap_client     => $args{riap_client},
         );
 
         if (my $sm = $specmeta->{$ospec}) {
             $cargs{type} = 'optval';
             if ($sm->{arg}) {
                 $log->tracef("[comp][periscomp] completing option value for a known function argument, arg=<%s>, ospec=<%s>", $sm->{arg}, $ospec);
                 $cargs{arg} = $sm->{arg};
                 my $arg_spec = $args_prop->{$sm->{arg}} or goto RETURN_RES;
                 if ($comp) {
                     $log->tracef("[comp][periscomp] invoking routine supplied from 'completion' argument");
                     my $compres;
                     eval { $compres = $comp->(%cargs) };
                     $log->debug("[comp][periscomp] completion died: $@") if $@;
                     $log->tracef("[comp][periscomp] result from 'completion' routine: %s", $compres);
                     if ($compres) {
                         $fres = $compres;
                         goto RETURN_RES;
                     }
                 }
                 if ($ospec =~ /\@$/) {
                     $fres = complete_arg_elem(
                         meta=>$meta, arg=>$sm->{arg}, args=>$gares->[2],
                         word=>$word, index=>$cargs{nth}, 
                         extras=>$extras, %rargs);
                     goto RETURN_RES;
                 } else {
                     $fres = complete_arg_val(
                         meta=>$meta, arg=>$sm->{arg}, args=>$gares->[2],
                         word=>$word, extras=>$extras, %rargs);
                     goto RETURN_RES;
                 }
             } else {
                 $log->tracef("[comp][periscomp] completing option value for a common option, ospec=<%s>", $ospec);
                 $cargs{arg}  = undef;
                 my $codata = $copts_by_ospec->{$ospec};
                 if ($comp) {
                     $log->tracef("[comp][periscomp] invoking routine supplied from 'completion' argument");
                     my $res;
                     eval { $res = $comp->(%cargs) };
                     $log->debug("[comp][periscomp] completion died: $@") if $@;
                     if ($res) {
                         $fres = $res;
                         goto RETURN_RES;
                     }
                 }
                 if ($codata->{completion}) {
                     $cargs{arg}  = undef;
                     $log->tracef("[comp][periscomp] completing with common option's 'completion' property");
                     my $res;
                     eval { $res = $codata->{completion}->(%cargs) };
                     $log->debug("[comp][periscomp] completion died: $@") if $@;
                     if ($res) {
                         $fres = $res;
                         goto RETURN_RES;
                     }
                 }
                 if ($codata->{schema}) {
                     require Data::Sah::Normalize;
                     my $nsch = Data::Sah::Normalize::normalize_schema(
                         $codata->{schema});
                     $log->tracef("[comp][periscomp] completing with common option's schema");
                     $fres = complete_from_schema(
                         schema => $nsch, word=>$word, ci=>$ci);
                     goto RETURN_RES;
                 }
                 goto RETURN_RES;
             }
         } elsif ($type eq 'arg') {
             $log->tracef("[comp][periscomp] completing argument #%d", $cargs{argpos});
             $cargs{type} = 'arg';
 
             my $pos = $cargs{argpos};
             my $fasa = $args{func_arg_starts_at} // 0;
 
             for my $an (keys %$args_prop) {
                 my $arg_spec = $args_prop->{$an};
                 next unless !$arg_spec->{greedy} &&
                     defined($arg_spec->{pos}) && $arg_spec->{pos} == $pos - $fasa;
                 $log->tracef("[comp][periscomp] this argument position is for non-greedy function argument <%s>", $an);
                 $cargs{arg} = $an;
                 if ($comp) {
                     $log->tracef("[comp][periscomp] invoking routine supplied from 'completion' argument");
                     my $res;
                     eval { $res = $comp->(%cargs) };
                     $log->debug("[comp][periscomp] completion died: $@") if $@;
                     if ($res) {
                         $fres = $res;
                         goto RETURN_RES;
                     }
                 }
                 $fres = complete_arg_val(
                     meta=>$meta, arg=>$an, args=>$gares->[2],
                     word=>$word, extras=>$extras, %rargs);
                 goto RETURN_RES;
             }
 
             for my $an (sort {
                 ($args_prop->{$b}{pos} // 9999) <=> ($args_prop->{$a}{pos} // 9999)
             } keys %$args_prop) {
                 my $arg_spec = $args_prop->{$an};
                 next unless $arg_spec->{greedy} &&
                     defined($arg_spec->{pos}) && $arg_spec->{pos} <= $pos - $fasa;
                 my $index = $pos - $fasa - $arg_spec->{pos};
                 $cargs{arg} = $an;
                 $cargs{index} = $index;
                 $log->tracef("[comp][periscomp] this position is for greedy function argument <%s>'s element[%d]", $an, $index);
                 if ($comp) {
                     $log->tracef("[comp][periscomp] invoking routine supplied from 'completion' argument");
                     my $res;
                     eval { $res = $comp->(%cargs) };
                     $log->debug("[comp][periscomp] completion died: $@") if $@;
                     if ($res) {
                         $fres = $res;
                         goto RETURN_RES;
                     }
                 }
                 $fres = complete_arg_elem(
                     meta=>$meta, arg=>$an, args=>$gares->[2],
                     word=>$word, index=>$index, extras=>$extras, %rargs);
                 goto RETURN_RES;
             }
 
             $log->tracef("[comp][periscomp] there is no matching function argument at this position");
             if ($comp) {
                 $log->tracef("[comp][periscomp] invoking routine supplied from 'completion' argument");
                 my $res;
                 eval { $res = $comp->(%cargs) };
                 $log->debug("[comp][periscomp] completion died: $@") if $@;
                 if ($res) {
                     $fres = $res;
                     goto RETURN_RES;
                 }
             }
             goto RETURN_RES;
         } else {
             $log->tracef("[comp][periscomp] completing option value for an unknown/ambiguous option, declining ...");
             goto RETURN_RES;
         }
       RETURN_RES:
         $log->tracef("[comp][periscomp] leaving completion routine (that we supply to Complete::Getopt::Long)");
         $fres;
     }; 
 
     $fres = Complete::Getopt::Long::complete_cli_arg(
         getopt_spec => $gospec,
         words       => $words,
         cword       => $cword,
         completion  => $compgl_comp,
         extras      => $extras,
     );
 
   RETURN_RES:
     $log->tracef('[comp][periscomp] leaving %s(), result=%s',
                  $fname, $fres);
     $fres;
 }
 
 1;
 
 __END__
 
### Perinci/Sub/ConvertArgs/Argv.pm ###
 package Perinci::Sub::ConvertArgs::Argv;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.05'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(convert_args_to_argv);
 
 our %SPEC;
 
 sub _json {
     require JSON;
     state $json = JSON->new->allow_nonref;
     $json->encode($_[0]);
 }
 
 sub _encode {
     ref($_[0]) ? _json($_[0]) : $_[0];
 }
 
 $SPEC{convert_args_to_argv} = {
     v => 1.1,
     summary => 'Convert hash arguments to command-line options (and arguments)',
     description => <<'_',
 
 Convert hash arguments to command-line arguments. This is the reverse of
 `Perinci::Sub::GetArgs::Argv::get_args_from_argv`.
 
 Note: currently the function expects schemas in metadata to be normalized
 already.
 
 _
     args => {
         args => {req=>1, schema=>'hash*', pos=>0},
         meta => {req=>0, schema=>'hash*', pos=>1},
         use_pos => {
             summary => 'Whether to use positional arguments',
             schema  => 'bool',
             description => <<'_',
 
 For example, given this metadata:
 
     {
         v => 1.1,
         args => {
           arg1 => {pos=>0, req=>1},
           arg2 => {pos=>1},
           arg3 => {},
         },
     }
 
 then under `use_pos=0` the hash `{arg1=>1, arg2=>2, arg3=>'a b'}` will be
 converted to `['--arg1', 1, '--arg2', 2, '--arg3', 'a b']`. Meanwhile if
 `use_pos=1` the same hash will be converted to `[1, 2, '--arg3', 'a b']`.
 
 _
         },
     },
 };
 sub convert_args_to_argv {
     my %fargs = @_;
 
     my $iargs = $fargs{args} or return [400, "Please specify args"];
     my $meta  = $fargs{meta} // {v=>1.1};
     my $args_prop = $meta->{args} // {};
 
     my $v = $meta->{v} // 1.0;
     return [412, "Sorry, only metadata version 1.1 is supported (yours: $v)"]
         unless $v == 1.1;
 
     my @argv;
     my %iargs = %$iargs; 
 
     if ($fargs{use_pos}) {
         for (sort {$args_prop->{$a}{pos} <=> $args_prop->{$b}{pos}}
                  grep {defined $args_prop->{$_}{pos}} keys %iargs) {
             $argv[ $args_prop->{$_}{pos} ] = _encode($iargs{$_});
             delete $iargs{$_};
         }
     }
 
     for (sort keys %iargs) {
         my $is_bool = $args_prop->{$_}{schema} &&
             $args_prop->{$_}{schema}[0] eq 'bool';
         my $opt = $_; $opt =~ s/_/-/g;
         my $dashopt = length($opt) > 1 ? "--$opt" : "-$opt";
         if ($is_bool) {
             if ($iargs{$_}) {
                 push @argv, $dashopt;
             } else {
                 push @argv, "--no$opt";
             }
         } else {
             if (ref $iargs{$_}) {
                 push @argv, "$dashopt-json", _encode($iargs{$_});
             } else {
                 push @argv, $dashopt, "$iargs{$_}";
             }
         }
     }
     [200, "OK", \@argv];
 }
 
 1;
 
 __END__
 
### Perinci/Sub/ConvertArgs/Array.pm ###
 package Perinci::Sub::ConvertArgs::Array;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '0.07'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(convert_args_to_array);
 
 our %SPEC;
 
 $SPEC{convert_args_to_array} = {
     v => 1.1,
     summary => 'Convert hash arguments to array',
     description => <<'_',
 
 Using information in 'args' property (particularly the 'pos' and 'greedy' of
 each argument spec), convert hash arguments to array.
 
 Example:
 
     my $meta = {
         v => 1.1,
         summary => 'Multiply 2 numbers (a & b)',
         args => {
             a => ['num*' => {arg_pos=>0}],
             b => ['num*' => {arg_pos=>1}],
         }
     }
 
 then 'convert_args_to_array(args=>{a=>2, b=>3}, meta=>$meta)' will produce:
 
     [200, "OK", [2, 3]]
 
 _
     args => {
         args => {req=>1, schema=>'hash*', pos=>0},
         meta => {req=>1, schema=>'hash*', pos=>1},
     },
 };
 sub convert_args_to_array {
     my %input_args   = @_;
     my $args         = $input_args{args} or return [400, "Please specify args"];
     my $meta         = $input_args{meta} or return [400, "Please specify meta"];
     my $args_prop    = $meta->{args} // {};
 
     my $v = $meta->{v} // 1.0;
     return [412, "Sorry, only metadata version 1.1 is supported (yours: $v)"]
         unless $v == 1.1;
 
 
     my @array;
 
     while (my ($k, $v) = each %$args) {
         my $as = $args_prop->{$k};
         return [412, "Argument $k: Not specified in args property"] unless $as;
         my $pos = $as->{pos};
         return [412, "Argument $k: No pos specified in arg spec"]
             unless defined $pos;
         if ($as->{greedy}) {
             $v = [$v] if ref($v) ne 'ARRAY';
             for (@array .. $pos-1) {
                 $array[$_] = undef;
             }
             splice @array, $pos, 0, @$v;
         } else {
             $array[$pos] = $v;
         }
     }
     [200, "OK", \@array];
 }
 
 1;
 
 __END__
 
### Perinci/Sub/DepChecker.pm ###
 package Perinci::Sub::DepChecker;
 
 use 5.010001;
 use strict;
 use warnings;
 use experimental 'smartmatch';
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        check_deps
                        dep_satisfy_rel
                        list_mentioned_dep_clauses
                );
 
 our $VERSION = '0.11'; 
 our $DATE = '2015-09-03'; 
 
 my $pa;
 
 sub check_deps {
     my ($val) = @_;
     for my $dname (keys %$val) {
         my $dval = $val->{$dname};
         unless (defined &{"checkdep_$dname"}) {
             eval { require "Perinci/Sub/Dep/$dname.pm" };
             return "Unknown dependency type: $dname"
                 unless defined &{"checkdep_$dname"};
         }
         my $check = \&{"checkdep_$dname"};
         my $res = $check->($dval);
         if ($res) {
             $res = "$dname: $res";
             return $res;
         }
     }
     "";
 }
 
 sub checkdep_all {
     my ($val) = @_;
     for (@$val) {
         my $res = check_deps($_);
         return "Some dependencies not met: $res" if $res;
     }
     "";
 }
 
 sub checkdep_any {
     my ($val) = @_;
     my $nfail = 0;
     for (@$val) {
         return "" unless check_deps($_);
         $nfail++;
     }
     $nfail ? "None of the dependencies are met" : "";
 }
 
 sub checkdep_none {
     my ($val) = @_;
     for (@$val) {
         my $res = check_deps($_);
         return "A dependency is met when it shouldn't: $res" unless $res;
     }
     "";
 }
 
 sub checkdep_env {
     my ($cval) = @_;
     $ENV{$cval} ? "" : "Environment variable $cval not set/true";
 }
 
 sub checkdep_code {
     my ($cval) = @_;
     $cval->() ? "" : "code doesn't return true value";
 }
 
 sub checkdep_prog {
     my ($cval) = @_;
 
     if ($cval =~ m!/!) {
         return "Program $cval not executable" unless (-x $cval);
     } else {
         require File::Which;
         return "Program $cval not found in PATH (".
             join(":", File::Spec->path).")"
                 unless File::Which::which($cval);
     }
     "";
 }
 
 sub riap_client {
     return $pa if $pa;
     require Perinci::Access;
     $pa = Perinci::Access->new;
     $pa;
 }
 
 sub checkdep_pkg {
     my ($cval) = @_;
     my $res = riap_client->request(info => $cval);
     $res->[0] == 200 or return "Can't perform 'info' Riap request on '$cval': ".
         "$res->[0] $res->[1]";
     $res->[2]{type} eq 'package' or return "$cval is not a Riap package";
     "";
 }
 
 sub checkdep_func {
     my ($cval) = @_;
     my $res = riap_client->request(info => $cval);
     $res->[0] == 200 or return "Can't perform 'info' Riap request on '$cval': ".
         "$res->[0] $res->[1]";
     $res->[2]{type} eq 'function' or return "$cval is not a Riap function";
     "";
 }
 
 sub checkdep_exec { checkdep_prog(@_) }
 
 sub checkdep_tmp_dir { "" }
 
 sub checkdep_trash_dir { "" }
 
 sub checkdep_undo_trash_dir { "" }
 
 sub _all_elems_is {
     my ($ary, $el) = @_;
     (grep {$_ eq $el} @$ary) && !(grep {$_ ne $el} @$ary);
 }
 
 sub _all_nonblank_elems_is {
     my ($ary, $el) = @_;
     (grep {$_ eq $el} @$ary) && !(grep {$_ && $_ ne $el} @$ary);
 }
 
 sub dep_satisfy_rel {
     my ($wanted, $deps) = @_;
 
     my $res;
     for my $dname (keys %$deps) {
         my $dval = $deps->{$dname};
 
         if ($dname eq 'all') {
             my @r = map { dep_satisfy_rel($wanted, $_) } @$dval;
             next unless @r;
             return "impossible" if "impossible" ~~ @r;
             return "impossible" if "must" ~~ @r && "must not" ~~ @r;
             return "must"       if "must" ~~ @r;
             return "must not"   if "must not" ~~ @r;
             return "might"      if _all_nonblank_elems_is(\@r, "might");
         } elsif ($dname eq 'any') {
             my @r = map { dep_satisfy_rel($wanted, $_) } @$dval;
             next unless @r;
             return "impossible" if "impossible" ~~ @r;
             return "must"       if _all_elems_is(\@r, "must");
             return "must not"   if _all_elems_is(\@r, "must not");
             next                if _all_elems_is(\@r, "");
             return "might";
         } elsif ($dname eq 'none') {
             my @r = map { dep_satisfy_rel($wanted, $_) } @$dval;
             next unless @r;
             return "impossible" if "impossible" ~~ @r;
             return "impossible" if "must" ~~ @r && "must not" ~~ @r;
             return "must not"   if "must" ~~ @r;
             return "must"       if "must not" ~~ @r;
             return "might"      if _all_nonblank_elems_is(\@r, "might");
         } else {
             return "must" if $dname eq $wanted;
         }
     }
     "";
 }
 
 sub list_mentioned_dep_clauses {
     my ($deps, $res) = @_;
     $res //= [];
     for my $dname (keys %$deps) {
         my $dval = $deps->{$dname};
         push @$res, $dname unless $dname ~~ @$res;
         if ($dname =~ /\A(?:all|any|none)\z/) {
             list_mentioned_dep_clauses($_, $res) for @$dval;
         }
     }
     $res;
 }
 
 1;
 
 __END__
 
### Perinci/Sub/GetArgs/Argv.pm ###
 package Perinci::Sub::GetArgs::Argv;
 
 our $DATE = '2015-08-19'; 
 our $VERSION = '0.69'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Data::Sah::Normalize qw(normalize_schema);
 use Getopt::Long::Negate::EN qw(negations_for_option);
 use Getopt::Long::Util qw(parse_getopt_long_opt_spec);
 use List::Util qw(first);
 use Perinci::Sub::GetArgs::Array qw(get_args_from_array);
 use Perinci::Sub::Util qw(err);
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        gen_getopt_long_spec_from_meta
                        get_args_from_argv
                );
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'Get subroutine arguments from command line arguments (@ARGV)',
 };
 
 my $re_simple_scalar = qr/^(str|num|int|float|bool|buf|re|date|duration)$/;
 
 sub _parse_json {
     my $str = shift;
 
     state $json = do {
         require JSON::PP;
         JSON::PP->new->allow_nonref;
     };
 
     state $cleanser = do {
         if (eval { require Data::Clean::FromJSON; 1 }) {
             Data::Clean::FromJSON->get_cleanser;
         } else {
             undef;
         }
     };
 
     my $res;
     eval { $res = $json->decode($str); $cleanser->clean_in_place($res) if $cleanser };
     my $e = $@;
     return (!$e, $e, $res);
 }
 
 sub _parse_yaml {
     no warnings 'once';
 
     state $yaml_xs_available = do {
         if (eval { require YAML::XS; 1 }) {
             1;
         } else {
             require YAML::Old;
             0;
         }
     };
 
     my $str = shift;
 
     my $res;
     eval {
         if ($yaml_xs_available) {
             $res = YAML::XS::Load($str);
         } else {
             $str = "--- $str" unless $str =~ /\A--- /;
             $str .= "\n" unless $str =~ /\n\z/;
             $res = YAML::Old::Load($str);
         }
     };
     my $e = $@;
     return (!$e, $e, $res);
 }
 
 sub _arg2opt {
     my $opt = shift;
     $opt =~ s/[^A-Za-z0-9-]+/-/g; 
     $opt;
 }
 
 sub _opt2ospec {
     my ($opt, $schema, $arg_spec) = @_;
     my $type = $schema->[0];
     my $cs   = $schema->[1];
     my $is_array_of_simple_scalar = $type eq 'array' &&
         $cs->{of} && $cs->{of}[0] =~ $re_simple_scalar;
     if ($is_array_of_simple_scalar && $arg_spec && $arg_spec->{'x.name.is_plural'}) {
         if ($arg_spec->{'x.name.singular'}) {
             $opt = $arg_spec->{'x.name.singular'};
         } else {
             require Lingua::EN::PluralToSingular;
             $opt = Lingua::EN::PluralToSingular::to_singular($opt);
         }
     }
     if ($type eq 'bool') {
         if (length($opt) == 1 || $cs->{is}) {
             return ($opt, {opts=>[$opt]});
         } else {
             my @res;
             my @negs = negations_for_option($opt);
             push @res, $opt, {opts=>[$opt]}, {is_neg=>0, neg_opts=>\@negs};
             for (@negs) {
                 push @res, $_, {opts=>[$_]}, {is_neg=>1, pos_opts=>[$opt]};
             }
             return @res;
         }
     } elsif ($type eq 'buf') {
         return (
             "$opt=s", {opts=>[$opt], desttype=>"", type=>"s"}, undef,
             "$opt-base64=s", {opts=>["$opt-base64"], desttype=>"", type=>"s"}, {is_base64=>1},
         );
     } else {
         my $t = ($type eq 'int' ? 'i' : $type eq 'float' ? 'f' :
                      $is_array_of_simple_scalar ? 's@' : 's');
         return ("$opt=$t", {opts=>[$opt], desttype=>"", type=>$t});
     }
 }
 
 sub _args2opts {
     my %args = @_;
 
     my $argprefix        = $args{argprefix};
     my $parent_args      = $args{parent_args};
     my $meta             = $args{meta};
     my $seen_opts        = $args{seen_opts};
     my $seen_common_opts = $args{seen_common_opts};
     my $seen_func_opts   = $args{seen_func_opts};
     my $rargs            = $args{rargs};
     my $go_spec          = $args{go_spec};
     my $specmeta         = $args{specmeta};
 
     my $args_prop = $meta->{args} // {};
 
     for my $arg (keys %$args_prop) {
         my $fqarg    = "$argprefix$arg";
         my $arg_spec = $args_prop->{$arg};
         my $sch      = $arg_spec->{schema} // ['any', {}];
         my $type     = $sch->[0] // '';
         my $cs       = $sch->[1] // {};
 
         if ($type eq 'array' && $cs->{of}) {
             $cs->{of} = normalize_schema($cs->{of});
         }
         my $opt = _arg2opt($fqarg);
         if ($seen_opts->{$opt}) {
             my $i = 1;
             my $opt2;
             while (1) {
                 $opt2 = "$opt-arg" . ($i > 1 ? $i : '');
                 last unless $seen_opts->{$opt2};
                 $i++;
             }
             $opt = $opt2;
         }
 
         my $is_simple_scalar = $type =~ $re_simple_scalar;
         my $is_array_of_simple_scalar = $type eq 'array' &&
             $cs->{of} && $cs->{of}[0] =~ $re_simple_scalar;
 
         my $stash = {};
 
 
         my $handler = sub {
             my ($val, $val_set);
 
             my $num_called = ++$stash->{called}{$arg};
 
             my $rargs = do {
                 if (ref($rargs) eq 'ARRAY') {
                     $rargs->[$num_called-1] //= {};
                     $rargs->[$num_called-1];
                 } else {
                     $rargs;
                 }
             };
 
             if ($is_array_of_simple_scalar) {
                 $rargs->{$arg} //= [];
                 $val_set = 1; $val = $_[1];
                 push @{ $rargs->{$arg} }, $val;
             } elsif ($is_simple_scalar) {
                 $val_set = 1; $val = $_[1];
                 $rargs->{$arg} = $val;
             } else {
                 {
                     my ($success, $e, $decoded);
                     ($success, $e, $decoded) = _parse_json($_[1]);
                     if ($success) {
                         $val_set = 1; $val = $decoded;
                         $rargs->{$arg} = $val;
                         last;
                     }
                     ($success, $e, $decoded) = _parse_yaml($_[1]);
                     if ($success) {
                         $val_set = 1; $val = $decoded;
                         $rargs->{$arg} = $val;
                         last;
                     }
                     die "Invalid YAML/JSON in arg '$fqarg'";
                 }
             }
             if ($val_set && $arg_spec->{cmdline_on_getopt}) {
                 $arg_spec->{cmdline_on_getopt}->(
                     arg=>$arg, fqarg=>$fqarg, value=>$val, args=>$rargs,
                     opt=>$opt,
                 );
             }
         }; 
 
         my @triplets = _opt2ospec($opt, $sch, $arg_spec);
         my $aliases_processed;
         while (my ($ospec, $parsed, $extra) = splice @triplets, 0, 3) {
             $extra //= {};
             if ($extra->{is_neg}) {
                 $go_spec->{$ospec} = sub { $handler->($_[0], 0) };
             } elsif (defined $extra->{is_neg}) {
                 $go_spec->{$ospec} = sub { $handler->($_[0], 1) };
             } elsif ($extra->{is_base64}) {
                 $go_spec->{$ospec} = sub {
                     require MIME::Base64;
                     my $decoded = MIME::Base64::decode($_[1]);
                     $handler->($_[0], $decoded);
                 };
             } else {
                 $go_spec->{$ospec} = $handler;
             }
 
             $specmeta->{$ospec} = {arg=>$arg, fqarg=>$fqarg, parsed=>$parsed, %$extra};
             for (@{ $parsed->{opts} }) {
                 $seen_opts->{$_}++; $seen_func_opts->{$_} = $fqarg;
             }
 
             if ($parent_args->{per_arg_json} && $type !~ $re_simple_scalar) {
                 my $jopt = "$opt-json";
                 if ($seen_opts->{$jopt}) {
                     warn "Clash of option: $jopt, not added";
                 } else {
                     my $jospec = "$jopt=s";
                     my $parsed = {type=>"s", opts=>[$jopt]};
                     $go_spec->{$jospec} = sub {
                         my ($success, $e, $decoded);
                         ($success, $e, $decoded) = _parse_json($_[1]);
                         if ($success) {
                             $rargs->{$arg} = $decoded;
                         } else {
                             die "Invalid JSON in option --$jopt: $_[1]: $e";
                         }
                     };
                     $specmeta->{$jospec} = {arg=>$arg, fqarg=>$fqarg, is_json=>1, parsed=>$parsed, %$extra};
                     $seen_opts->{$jopt}++; $seen_func_opts->{$jopt} = $fqarg;
                 }
             }
             if ($parent_args->{per_arg_yaml} && $type !~ $re_simple_scalar) {
                 my $yopt = "$opt-yaml";
                 if ($seen_opts->{$yopt}) {
                     warn "Clash of option: $yopt, not added";
                 } else {
                     my $yospec = "$yopt=s";
                     my $parsed = {type=>"s", opts=>[$yopt]};
                     $go_spec->{$yospec} = sub {
                         my ($success, $e, $decoded);
                         ($success, $e, $decoded) = _parse_yaml($_[1]);
                         if ($success) {
                             $rargs->{$arg} = $decoded;
                         } else {
                             die "Invalid YAML in option --$yopt: $_[1]: $e";
                         }
                     };
                     $specmeta->{$yospec} = {arg=>$arg, fqarg=>$fqarg, is_yaml=>1, parsed=>$parsed, %$extra};
                     $seen_opts->{$yopt}++; $seen_func_opts->{$yopt} = $fqarg;
                 }
             }
 
             if ($arg_spec->{cmdline_aliases} && !$aliases_processed++) {
                 for my $al (keys %{$arg_spec->{cmdline_aliases}}) {
                     my $alspec = $arg_spec->{cmdline_aliases}{$al};
                     my $alsch = $alspec->{schema} //
                         $alspec->{is_flag} ? [bool=>{req=>1,is=>1}] : $sch;
                     my $altype = $alsch->[0];
                     my $alopt = _arg2opt("$argprefix$al");
                     if ($seen_opts->{$alopt}) {
                         warn "Clash of cmdline_alias option $al";
                         next;
                     }
                     my $alcode = $alspec->{code};
                     my $alospec;
                     my $parsed;
                     if ($alcode && $alsch->[0] eq 'bool') {
                         $alospec = $alopt; 
                         $parsed = {opts=>[$alopt]};
                     } else {
                         ($alospec, $parsed) = _opt2ospec($alopt, $alsch);
                     }
 
                     if ($alcode) {
                         if ($alcode eq 'CODE') {
                             if ($parent_args->{ignore_converted_code}) {
                                 $alcode = sub {};
                             } else {
                                 return [
                                     501,
                                     join("",
                                          "Code in cmdline_aliases for arg $fqarg ",
                                          "got converted into string, probably ",
                                          "because of JSON/YAML transport"),
                                 ];
                             }
                         }
                         $go_spec->{$alospec} = sub {
 
                             my $num_called = ++$stash->{called}{$arg};
                             my $rargs = do {
                                 if (ref($rargs) eq 'ARRAY') {
                                     $rargs->[$num_called-1] //= {};
                                     $rargs->[$num_called-1];
                                 } else {
                                     $rargs;
                                 }
                             };
 
                             $alcode->($rargs, $_[1]);
                         };
                     } else {
                         $go_spec->{$alospec} = $handler;
                     }
                     $specmeta->{$alospec} = {
                         alias     => $al,
                         is_alias  => 1,
                         alias_for => $ospec,
                         arg       => $arg,
                         fqarg     => $fqarg,
                         is_code   => $alcode ? 1:0,
                         parsed    => $parsed,
                         %$extra,
                     };
                     push @{$specmeta->{$ospec}{($alcode ? '':'non').'code_aliases'}},
                         $alospec;
                     $seen_opts->{$alopt}++; $seen_func_opts->{$alopt} = $fqarg;
                 }
             } 
 
             if ($arg_spec->{meta}) {
                 $rargs->{$arg} = {};
                 my $res = _args2opts(
                     %args,
                     argprefix => "$argprefix$arg\::",
                     meta      => $arg_spec->{meta},
                     rargs     => $rargs->{$arg},
                 );
                 return $res if $res;
             }
 
             if ($arg_spec->{element_meta}) {
                 $rargs->{$arg} = [];
                 my $res = _args2opts(
                     %args,
                     argprefix => "$argprefix$arg\::",
                     meta      => $arg_spec->{element_meta},
                     rargs     => $rargs->{$arg},
                 );
                 return $res if $res;
             }
         } 
 
     } 
 
     undef;
 }
 
 $SPEC{gen_getopt_long_spec_from_meta} = {
     v           => 1.1,
     summary     => 'Generate Getopt::Long spec from Rinci function metadata',
     description => <<'_',
 
 This routine will produce a `Getopt::Long` specification from Rinci function
 metadata, as well as some more data structure in the result metadata to help
 producing a command-line help/usage message.
 
 Function arguments will be mapped to command-line options with the same name,
 with non-alphanumeric characters changed to `-` (`-` is preferred over `_`
 because it lets user avoid pressing Shift on popular keyboards). For example:
 `file_size` becomes `file-size`, `file_size.max` becomes `file-size-max`. If
 function argument option name clashes with command-line option or another
 existing option, it will be renamed to `NAME-arg` (or `NAME-arg2` and so on).
 For example: `help` will become `help-arg` (if `common_opts` contains `help`,
 that is).
 
 Each command-line alias (`cmdline_aliases` property) in the argument
 specification will also be added as command-line option, except if it clashes
 with an existing option, in which case this function will warn and skip adding
 the alias. For more information about `cmdline_aliases`, see `Rinci::function`.
 
 For arguments with type of `bool`, Getopt::Long will by default also
 automatically recognize `--noNAME` or `--no-NAME` in addition to `--name`. So
 this function will also check those names for clashes.
 
 For arguments with type array of simple scalar, `--NAME` can be specified more
 than once to append to the array.
 
 If `per_arg_json` setting is active, and argument's schema is not a "required
 simple scalar" (e.g. an array, or a nullable string), then `--NAME-json` will
 also be added to let users input undef (through `--NAME-json null`) or a
 non-scalar value (e.g. `--NAME-json '[1,2,3]'`). If this name conflicts with
 another existing option, a warning will be displayed and the option will not be
 added.
 
 If `per_arg_yaml` setting is active, and argument's schema is not a "required
 simple scalar" (e.g. an array, or a nullable string), then `--NAME-yaml` will
 also be added to let users input undef (through `--NAME-yaml '~'`) or a
 non-scalar value (e.g. `--NAME-yaml '[foo, bar]'`). If this name conflicts with
 another existing option, a warning will be displayed and the option will not be
 added. YAML can express a larger set of values, e.g. binary data, circular
 references, etc.
 
 Will produce a hash (Getopt::Long spec), with `func.specmeta`, `func.opts`,
 `func.common_opts`, `func.func_opts` that contain extra information
 (`func.specmeta` is a hash of getopt spec name and a hash of extra information
 while `func.*opts` lists all used option names).
 
 _
     args => {
         meta => {
             summary => 'Rinci function metadata',
             schema  => 'hash*',
             req     => 1,
         },
         meta_is_normalized => {
             schema => 'bool*',
         },
         args => {
             summary => 'Reference to hash which will store the result',
             schema  => 'hash*',
         },
         common_opts => {
             summary => 'Common options',
             description => <<'_',
 
 A hash where the values are hashes containing these keys: `getopt` (Getopt::Long
 option specification), `handler` (Getopt::Long handler). Will be passed to
 `get_args_from_argv()`. Example:
 
     {
         help => {
             getopt  => 'help|h|?',
             handler => sub { ... },
             summary => 'Display help and exit',
         },
         version => {
             getopt  => 'version|v',
             handler => sub { ... },
             summary => 'Display version and exit',
         },
     }
 
 _
             schema => ['hash*'],
         },
         per_arg_json => {
             summary => 'Whether to add --NAME-json for non-simple arguments',
             schema  => 'bool',
             default => 0,
             description => <<'_',
 
 Will also interpret command-line arguments as JSON if assigned to function
 arguments, if arguments' schema is not simple scalar.
 
 _
         },
         per_arg_yaml => {
             summary => 'Whether to add --NAME-yaml for non-simple arguments',
             schema  => 'bool',
             default => 0,
             description => <<'_',
 
 Will also interpret command-line arguments as YAML if assigned to function
 arguments, if arguments' schema is not simple scalar.
 
 _
         },
         ignore_converted_code => {
             summary => 'Whether to ignore coderefs converted to string',
             schema => 'bool',
             default => 0,
             description => <<'_',
 
 Across network through JSON encoding, coderef in metadata (e.g. in
 `cmdline_aliases` property) usually gets converted to string `CODE`. In some
 cases, like for tab completion, this is pretty harmless so you can turn this
 option on. For example, in the case of `cmdline_aliases`, the effect is just
 that command-line aliases code are not getting executed, but this is usually
 okay.
 
 _
         },
     },
 };
 sub gen_getopt_long_spec_from_meta {
     my %fargs = @_;
 
     my $meta       = $fargs{meta} or return [400, "Please specify meta"];
     unless ($fargs{meta_is_normalized}) {
         require Perinci::Sub::Normalize;
         $meta = Perinci::Sub::Normalize::normalize_function_metadata($meta);
     }
     my $co           = $fargs{common_opts} // {};
     my $per_arg_yaml = $fargs{per_arg_yaml} // 0;
     my $per_arg_json = $fargs{per_arg_json} // 0;
     my $ignore_converted_code = $fargs{ignore_converted_code};
     my $rargs        = $fargs{args} // {};
 
     my %go_spec;
     my %specmeta; 
     my %seen_opts;
     my %seen_common_opts;
     my %seen_func_opts;
 
     for my $k (keys %$co) {
         my $v = $co->{$k};
         my $ospec   = $v->{getopt};
         my $handler = $v->{handler};
         my $res = parse_getopt_long_opt_spec($ospec)
             or return [400, "Can't parse common opt spec '$ospec'"];
         $go_spec{$ospec} = $handler;
         $specmeta{$ospec} = {common_opt=>$k, arg=>undef, parsed=>$res};
         for (@{ $res->{opts} }) {
             return [412, "Clash of common opt '$_'"] if $seen_opts{$_};
             $seen_opts{$_}++; $seen_common_opts{$_} = $ospec;
             if ($res->{is_neg}) {
                 $seen_opts{"no$_"}++ ; $seen_common_opts{"no$_"}  = $ospec;
                 $seen_opts{"no-$_"}++; $seen_common_opts{"no-$_"} = $ospec;
             }
         }
     }
 
     my $res = _args2opts(
         argprefix        => "",
         parent_args      => \%fargs,
         meta             => $meta,
         seen_opts        => \%seen_opts,
         seen_common_opts => \%seen_common_opts,
         seen_func_opts   => \%seen_func_opts,
         rargs            => $rargs,
         go_spec          => \%go_spec,
         specmeta         => \%specmeta,
     );
     return $res if $res;
 
     my $opts        = [sort(map {length($_)>1 ? "--$_":"-$_"} keys %seen_opts)];
     my $common_opts = [sort(map {length($_)>1 ? "--$_":"-$_"} keys %seen_common_opts)];
     my $func_opts   = [sort(map {length($_)>1 ? "--$_":"-$_"} keys %seen_func_opts)];
     my $opts_by_common = {};
     for my $k (keys %$co) {
         my $v = $co->{$k};
         my $ospec = $v->{getopt};
         my @opts;
         for (keys %seen_common_opts) {
             next unless $seen_common_opts{$_} eq $ospec;
             push @opts, (length($_)>1 ? "--$_":"-$_");
         }
         $opts_by_common->{$ospec} = [sort @opts];
     }
 
     my $opts_by_arg = {};
     for (keys %seen_func_opts) {
         my $fqarg = $seen_func_opts{$_};
         push @{ $opts_by_arg->{$fqarg} }, length($_)>1 ? "--$_":"-$_";
     }
     for (keys %$opts_by_arg) {
         $opts_by_arg->{$_} = [sort @{ $opts_by_arg->{$_} }];
     }
 
     [200, "OK", \%go_spec,
      {
          "func.specmeta"       => \%specmeta,
          "func.opts"           => $opts,
          "func.common_opts"    => $common_opts,
          "func.func_opts"      => $func_opts,
          "func.opts_by_arg"    => $opts_by_arg,
          "func.opts_by_common" => $opts_by_common,
      }];
 }
 
 $SPEC{get_args_from_argv} = {
     v => 1.1,
     summary => 'Get subroutine arguments (%args) from command-line arguments '.
         '(@ARGV)',
     description => <<'_',
 
 Using information in Rinci function metadata's `args` property, parse command
 line arguments `@argv` into hash `%args`, suitable for passing into subroutines.
 
 Currently uses Getopt::Long's GetOptions to do the parsing.
 
 As with GetOptions, this function modifies its `argv` argument, so you might
 want to copy the original `argv` first (or pass a copy instead) if you want to
 preserve the original.
 
 See also: gen_getopt_long_spec_from_meta() which is the routine that generates
 the specification.
 
 _
     args => {
         argv => {
             schema => ['array*' => {
                 of => 'str*',
             }],
             description => 'If not specified, defaults to @ARGV',
         },
         args => {
             summary => 'Specify input args, with some arguments preset',
             schema  => ['hash'],
         },
         meta => {
             schema => ['hash*' => {}],
             req => 1,
         },
         meta_is_normalized => {
             summary => 'Can be set to 1 if your metadata is normalized, '.
                 'to avoid duplicate effort',
             schema => 'bool',
             default => 0,
         },
         strict => {
             schema => ['bool' => {default=>1}],
             summary => 'Strict mode',
             description => <<'_',
 
 If set to 0, will still return parsed argv even if there are parsing errors
 (reported by Getopt::Long). If set to 1 (the default), will die upon error.
 
 Normally you would want to use strict mode, for more error checking. Setting off
 strict is used by, for example, Perinci::Sub::Complete during completion where
 the command-line might still be incomplete.
 
 Should probably be named `ignore_errors`. :-)
 
 _
         },
         per_arg_yaml => {
             schema => ['bool' => {default=>0}],
             summary => 'Whether to recognize --ARGNAME-yaml',
             description => <<'_',
 
 This is useful for example if you want to specify a value which is not
 expressible from the command-line, like 'undef'.
 
     % script.pl --name-yaml '~'
 
 See also: per_arg_json. You should enable just one instead of turning on both.
 
 _
         },
         per_arg_json => {
             schema => ['bool' => {default=>0}],
             summary => 'Whether to recognize --ARGNAME-json',
             description => <<'_',
 
 This is useful for example if you want to specify a value which is not
 expressible from the command-line, like 'undef'.
 
     % script.pl --name-json 'null'
 
 But every other string will need to be quoted:
 
     % script.pl --name-json '"foo"'
 
 See also: per_arg_yaml. You should enable just one instead of turning on both.
 
 _
         },
         common_opts => {
             summary => 'Common options',
             description => <<'_',
 
 A hash where the values are hashes containing these keys: `getopt` (Getopt::Long
 option specification), `handler` (Getopt::Long handler). Will be passed to
 `get_args_from_argv()`. Example:
 
     {
         help => {
             getopt  => 'help|h|?',
             handler => sub { ... },
             summary => 'Display help and exit',
         },
         version => {
             getopt  => 'version|v',
             handler => sub { ... },
             summary => 'Display version and exit',
         },
     }
 
 _
             schema => ['hash*'],
         },
         allow_extra_elems => {
             schema => ['bool' => {default=>0}],
             summary => 'Allow extra/unassigned elements in argv',
             description => <<'_',
 
 If set to 1, then if there are array elements unassigned to one of the
 arguments, instead of generating an error, this function will just ignore them.
 
 This option will be passed to Perinci::Sub::GetArgs::Array's allow_extra_elems.
 
 _
         },
         on_missing_required_args => {
             schema => 'code',
             summary => 'Execute code when there is missing required args',
             description => <<'_',
 
 This can be used to give a chance to supply argument value from other sources if
 not specified by command-line options. Perinci::CmdLine, for example, uses this
 hook to supply value from STDIN or file contents (if argument has `cmdline_src`
 specification key set).
 
 This hook will be called for each missing argument. It will be supplied hash
 arguments: (arg => $the_missing_argument_name, args =>
 $the_resulting_args_so_far, spec => $the_arg_spec).
 
 The hook can return true if it succeeds in making the missing situation
 resolved. In this case, this function will not report the argument as missing.
 
 _
         },
         ignore_converted_code => {
             summary => 'Whether to ignore coderefs converted to string',
             schema => 'bool',
             default => 0,
             description => <<'_',
 
 Across network through JSON encoding, coderef in metadata (e.g. in
 `cmdline_aliases` property) usually gets converted to string `CODE`. In some
 cases, like for tab completion, this is harmless so you can turn this option on.
 
 _
         },
     },
     result => {
         description => <<'_',
 
 Error codes:
 
 * 400 - Error in Getopt::Long option specification, e.g. in common_opts.
 
 * 500 - failure in GetOptions, meaning argv is not valid according to metadata
   specification (only if 'strict' mode is enabled).
 
 * 501 - coderef in cmdline_aliases got converted into a string, probably because
   the metadata was transported (e.g. through Riap::HTTP/Riap::Simple).
 
 _
     },
 };
 sub get_args_from_argv {
     require Getopt::Long;
 
     my %fargs = @_;
     my $argv       = $fargs{argv} // \@ARGV;
     my $meta       = $fargs{meta} or return [400, "Please specify meta"];
     unless ($fargs{meta_is_normalized}) {
         require Perinci::Sub::Normalize;
         $meta = Perinci::Sub::Normalize::normalize_function_metadata($meta);
     }
     my $strict            = $fargs{strict} // 1;
     my $common_opts       = $fargs{common_opts} // {};
     my $per_arg_yaml      = $fargs{per_arg_yaml} // 0;
     my $per_arg_json      = $fargs{per_arg_json} // 0;
     my $allow_extra_elems = $fargs{allow_extra_elems} // 0;
     my $on_missing        = $fargs{on_missing_required_args};
     my $ignore_converted_code = $fargs{ignore_converted_code};
 
     my $rargs = $fargs{args} // {};
 
     my $genres = gen_getopt_long_spec_from_meta(
         meta => $meta, meta_is_normalized => 1,
         args => $rargs,
         common_opts  => $common_opts,
         per_arg_json => $per_arg_json,
         per_arg_yaml => $per_arg_yaml,
         ignore_converted_code => $ignore_converted_code,
     );
     return err($genres->[0], "Can't generate Getopt::Long spec", $genres)
         if $genres->[0] != 200;
     my $go_spec = $genres->[2];
 
     {
         local $SIG{__WARN__} = sub{} if !$strict;
         my $old_go_conf = Getopt::Long::Configure(
             $strict ? "no_pass_through" : "pass_through",
             "no_ignore_case", "permute", "bundling", "no_getopt_compat");
         my $res = Getopt::Long::GetOptionsFromArray($argv, %$go_spec);
         Getopt::Long::Configure($old_go_conf);
         unless ($res) {
             return [500, "GetOptions failed"] if $strict;
         }
     }
 
 
     my $args_prop = $meta->{args};
 
     if (@$argv) {
         my $res = get_args_from_array(
             array=>$argv, meta => $meta,
             meta_is_normalized => 1,
             allow_extra_elems => $allow_extra_elems,
         );
         if ($res->[0] != 200 && $strict) {
             return err(500, "Get args from array failed", $res);
         } elsif ($strict && $res->[0] != 200) {
             return err("Can't get args from argv", $res);
         } elsif ($res->[0] == 200) {
             my $pos_args = $res->[2];
             for my $name (keys %$pos_args) {
                 my $arg_spec = $args_prop->{$name};
                 my $val      = $pos_args->{$name};
                 if (exists $rargs->{$name}) {
                     return [400, "You specified option --$name but also ".
                                 "argument #".$arg_spec->{pos}] if $strict;
                 }
                 my $type = $arg_spec->{schema}[0];
                 my $cs   = $arg_spec->{schema}[1];
                 my $is_simple_scalar = $type =~ $re_simple_scalar;
                 my $is_array_of_simple_scalar = $type eq 'array' &&
                     $cs->{of} && $cs->{of}[0] =~ $re_simple_scalar;
 
                 if ($arg_spec->{greedy} && ref($val) eq 'ARRAY' &&
                         !$is_array_of_simple_scalar) {
                     my $i = 0;
                     for (@$val) {
                       TRY_PARSING_AS_JSON_YAML:
                         {
                             my ($success, $e, $decoded);
                             if ($per_arg_json) {
                                 ($success, $e, $decoded) = _parse_json($_);
                                 if ($success) {
                                     $_ = $decoded;
                                     last TRY_PARSING_AS_JSON_YAML;
                                 } else {
                                     warn "Failed trying to parse argv #$i as JSON: $e";
                                 }
                             }
                             if ($per_arg_yaml) {
                                 ($success, $e, $decoded) = _parse_yaml($_);
                                 if ($success) {
                                     $_ = $decoded;
                                     last TRY_PARSING_AS_JSON_YAML;
                                 } else {
                                     warn "Failed trying to parse argv #$i as YAML: $e";
                                 }
                             }
                         }
                         $i++;
                     }
                 }
                 if (!$arg_spec->{greedy} && !$is_simple_scalar) {
                   TRY_PARSING_AS_JSON_YAML:
                     {
                         my ($success, $e, $decoded);
                         if ($per_arg_json) {
                             ($success, $e, $decoded) = _parse_json($val);
                             if ($success) {
                                 $val = $decoded;
                                 last TRY_PARSING_AS_JSON_YAML;
                             } else {
                                 warn "Failed trying to parse argv #$arg_spec->{pos} as JSON: $e";
                             }
                         }
                         if ($per_arg_yaml) {
                             ($success, $e, $decoded) = _parse_yaml($val);
                             if ($success) {
                                 $val = $decoded;
                                 last TRY_PARSING_AS_JSON_YAML;
                             } else {
                                 warn "Failed trying to parse argv #$arg_spec->{pos} as YAML: $e";
                             }
                         }
                     }
                 }
                 $rargs->{$name} = $val;
                 if ($arg_spec->{cmdline_on_getopt}) {
                     if ($arg_spec->{greedy}) {
                         $arg_spec->{cmdline_on_getopt}->(
                             arg=>$name, fqarg=>$name, value=>$_, args=>$rargs,
                             opt=>undef, 
                         ) for @$val;
                     } else {
                         $arg_spec->{cmdline_on_getopt}->(
                             arg=>$name, fqarg=>$name, value=>$val, args=>$rargs,
                             opt=>undef, 
                         );
                     }
                 }
             }
         }
     }
 
 
     my %missing_args;
     for my $arg (keys %$args_prop) {
         my $arg_spec = $args_prop->{$arg};
         if (!exists($rargs->{$arg})) {
             next unless $arg_spec->{req};
             if ($on_missing) {
                 next if $on_missing->(arg=>$arg, args=>$rargs, spec=>$arg_spec);
             }
             next if exists $rargs->{$arg};
             $missing_args{$arg} = 1;
         }
     }
 
     {
         last unless $strict;
 
         for my $arg (keys %$args_prop) {
             my $arg_spec = $args_prop->{$arg};
             next unless exists $rargs->{$arg};
             next unless $arg_spec->{deps};
             my $dep_arg = $arg_spec->{deps}{arg};
             next unless $dep_arg;
             return [400, "You specify '$arg', but don't specify '$dep_arg' ".
                         "(upon which '$arg' depends)"]
                 unless exists $rargs->{$dep_arg};
         }
     }
 
     [200, "OK", $rargs, {
         "func.missing_args" => [sort keys %missing_args],
         "func.gen_getopt_long_spec_result" => $genres,
     }];
 }
 
 1;
 
 __END__
 
### Perinci/Sub/GetArgs/Array.pm ###
 package Perinci::Sub::GetArgs::Array;
 
 our $DATE = '2015-09-04'; 
 our $VERSION = '0.15'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(get_args_from_array);
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
 };
 
 $SPEC{get_args_from_array} = {
     v => 1.1,
     summary => 'Get subroutine arguments (%args) from array',
     description => <<'_',
 
 Using information in metadata's `args` property (particularly the `pos` and
 `greedy` arg type clauses), extract arguments from an array into a hash
 `\%args`, suitable for passing into subs.
 
 Example:
 
     my $meta = {
         v => 1.1,
         summary => 'Multiply 2 numbers (a & b)',
         args => {
             a => {schema=>'num*', pos=>0},
             b => {schema=>'num*', pos=>1},
         }
     }
 
 then `get_args_from_array(array=>[2, 3], meta=>$meta)` will produce:
 
     [200, "OK", {a=>2, b=>3}]
 
 _
     args => {
         array => {
             schema => ['array*' => {}],
             req => 1,
             description => <<'_',
 
 NOTE: array will be modified/emptied (elements will be taken from the array as
 they are put into the resulting args). Copy your array first if you want to
 preserve its content.
 
 _
         },
         meta => {
             schema => ['hash*' => {}],
             req => 1,
         },
         meta_is_normalized => {
             summary => 'Can be set to 1 if your metadata is normalized, '.
                 'to avoid duplicate effort',
             schema => 'bool',
             default => 0,
         },
         allow_extra_elems => {
             schema => ['bool' => {default=>0}],
             summary => 'Allow extra/unassigned elements in array',
             description => <<'_',
 
 If set to 1, then if there are array elements unassigned to one of the arguments
 (due to missing `pos`, for example), instead of generating an error, the
 function will just ignore them.
 
 _
         },
     },
 };
 sub get_args_from_array {
     my %fargs = @_;
     my $ary  = $fargs{array} or return [400, "Please specify array"];
     my $meta = $fargs{meta} or return [400, "Please specify meta"];
     unless ($fargs{meta_is_normalized}) {
         require Perinci::Sub::Normalize;
         $meta = Perinci::Sub::Normalize::normalize_function_metadata(
             $meta);
     }
     my $allow_extra_elems = $fargs{allow_extra_elems} // 0;
 
     my $rargs = {};
 
     my $args_p = $meta->{args} // {};
     for my $i (reverse 0..@$ary-1) {
         while (my ($a, $as) = each %$args_p) {
             my $o = $as->{pos};
             if (defined($o) && $o == $i) {
                 if ($as->{greedy}) {
                     my $type = $as->{schema}[0];
                     my @elems = splice(@$ary, $i);
                     if ($type eq 'array') {
                         $rargs->{$a} = \@elems;
                     } else {
                         $rargs->{$a} = join " ", @elems;
                     }
                 } else {
                     $rargs->{$a} = splice(@$ary, $i, 1);
                 }
             }
         }
     }
 
     return [400, "There are extra, unassigned elements in array: [".
                 join(", ", @$ary)."]"] if @$ary && !$allow_extra_elems;
 
     [200, "OK", $rargs];
 }
 
 1;
 
 __END__
 
### Perinci/Sub/Normalize.pm ###
 package Perinci::Sub::Normalize;
 
 our $DATE = '2015-09-30'; 
 our $VERSION = '0.13'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        normalize_function_metadata
                );
 
 use Sah::Schema::Rinci;
 my $sch = $Sah::Schema::Rinci::SCHEMAS{rinci_function}
     or die "BUG: Rinci schema structure changed (1)";
 my $sch_proplist = $sch->[1]{_prop}
     or die "BUG: Rinci schema structure changed (2)";
 
 sub _normalize{
     my ($meta, $ver, $opts, $proplist, $nmeta, $prefix, $modprefix) = @_;
 
     my $opt_aup = $opts->{allow_unknown_properties};
     my $opt_nss = $opts->{normalize_sah_schemas};
     my $opt_rip = $opts->{remove_internal_properties};
 
     if (defined $ver) {
         defined($meta->{v}) && $meta->{v} eq $ver
             or die "$prefix: Metadata version must be $ver";
     }
 
   KEY:
     for my $k (keys %$meta) {
         die "Invalid prop/attr syntax '$k', must be word/dotted-word only"
             unless $k =~ /\A(\w+)(?:\.(\w+(?:\.\w+)*))?(?:\((\w+)\))?\z/;
 
         my ($prop, $attr);
         if (defined $3) {
             $prop = $1;
             $attr = defined($2) ? "$2.alt.lang.$3" : "alt.lang.$3";
         } else {
             $prop = $1;
             $attr = $2;
         }
 
         my $nk = "$prop" . (defined($attr) ? ".$attr" : "");
 
         if ($prop =~ /\A_/ || defined($attr) && $attr =~ /\A_|\._/) {
             unless ($opt_rip) {
                 $nmeta->{$nk} = $meta->{$k};
             }
             next KEY;
         }
 
         my $prop_proplist = $proplist->{$prop};
 
         if (!$opt_aup && !$prop_proplist) {
             $modprefix //= $prefix;
             my $mod = "Perinci/Sub/Property$modprefix/$prop.pm";
             eval { require $mod };
             if ($@) {
                 die "Unknown property '$prefix/$prop' (and couldn't ".
                     "load property module '$mod'): $@" if $@;
             }
             $prop_proplist = $proplist->{$prop};
         }
         die "Unknown property '$prefix/$prop'"
             unless $opt_aup || $prop_proplist;
 
         if ($prop_proplist && $prop_proplist->{_prop}) {
             die "Property '$prefix/$prop' must be a hash"
                 unless ref($meta->{$k}) eq 'HASH';
             $nmeta->{$nk} = {};
             _normalize(
                 $meta->{$k},
                 $prop_proplist->{_ver},
                 $opts,
                 $prop_proplist->{_prop},
                 $nmeta->{$nk},
                 "$prefix/$prop",
             );
         } elsif ($prop_proplist && $prop_proplist->{_elem_prop}) {
             die "Property '$prefix/$prop' must be an array"
                 unless ref($meta->{$k}) eq 'ARRAY';
             $nmeta->{$nk} = [];
             my $i = 0;
             for (@{ $meta->{$k} }) {
                 my $href = {};
                 if (ref($_) eq 'HASH') {
                     _normalize(
                         $_,
                         $prop_proplist->{_ver},
                         $opts,
                         $prop_proplist->{_elem_prop},
                         $href,
                         "$prefix/$prop/$i",
                     );
                     push @{ $nmeta->{$nk} }, $href;
                 } else {
                     push @{ $nmeta->{$nk} }, $_;
                 }
                 $i++;
             }
         } elsif ($prop_proplist && $prop_proplist->{_value_prop}) {
             die "Property '$prefix/$prop' must be a hash"
                 unless ref($meta->{$k}) eq 'HASH';
             $nmeta->{$nk} = {};
             for (keys %{ $meta->{$k} }) {
                 $nmeta->{$nk}{$_} = {};
                 die "Property '$prefix/$prop/$_' must be a hash"
                     unless ref($meta->{$k}{$_}) eq 'HASH';
                 _normalize(
                     $meta->{$k}{$_},
                     $prop_proplist->{_ver},
                     $opts,
                     $prop_proplist->{_value_prop},
                     $nmeta->{$nk}{$_},
                     "$prefix/$prop/$_",
                     ($prop eq 'args' ? "$prefix/arg" : undef),
                 );
             }
         } else {
             if ($k eq 'schema' && $opt_nss) { 
                 require Data::Sah::Normalize;
                 $nmeta->{$nk} = Data::Sah::Normalize::normalize_schema(
                     $meta->{$k});
             } else {
                 $nmeta->{$nk} = $meta->{$k};
             }
         }
     }
 
     $nmeta;
 }
 
 sub normalize_function_metadata($;$) {
     my ($meta, $opts) = @_;
 
     $opts //= {};
 
     $opts->{allow_unknown_properties}    //= 0;
     $opts->{normalize_sah_schemas}       //= 1;
     $opts->{remove_internal_properties}  //= 0;
 
     _normalize($meta, 1.1, $opts, $sch_proplist, {}, '');
 }
 
 1;
 
 __END__
 
### Perinci/Sub/To/CLIDocData.pm ###
 package Perinci::Sub::To::CLIDocData;
 
 our $DATE = '2015-09-23'; 
 our $VERSION = '0.23'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Perinci::Object;
 use Perinci::Sub::Util qw(err);
 
 our %SPEC;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(gen_cli_doc_data_from_meta);
 
 sub _has_cats {
     for my $spec (@{ $_[0] }) {
         for (@{ $spec->{tags} // [] }) {
             my $tag_name = ref($_) ? $_->{name} : $_;
             if ($tag_name =~ /^category:/) {
                 return 1;
             }
         }
     }
     0;
 }
 
 sub _add_category_from_spec {
     my ($cats_spec, $thing, $spec, $noun, $has_cats) = @_;
     my @cats;
     for (@{ $spec->{tags} // [] }) {
         my $tag_name = ref($_) ? $_->{name} : $_;
         if ($tag_name =~ /^category:(.+)/) {
             my $cat = ucfirst($1);
             $cat =~ s/-/ /g;
             $cat .= " " . $noun;
             push @cats, [$cat, 50]; 
         }
     }
     if (!@cats) {
         @cats = [$has_cats ? "Other $noun" : ucfirst($noun), 99]; 
     }
 
     $thing->{category} = $cats[0][0];
     $thing->{categories} = [map {$_->[0]} @cats];
 
     $cats_spec->{$_->[0]}{order} //= $_->[1] for @cats;
 }
 
 sub _add_default_from_arg_spec {
     my ($opt, $arg_spec) = @_;
     if (exists $arg_spec->{default}) {
         $opt->{default} = $arg_spec->{default};
     } elsif ($arg_spec->{schema} && exists($arg_spec->{schema}[1]{default})) {
         $opt->{default} = $arg_spec->{schema}[1]{default};
     }
 }
 
 sub _dash_prefix {
     length($_[0]) > 1 ? "--$_[0]" : "-$_[0]";
 }
 
 sub _fmt_opt {
     my $spec = shift;
     my @ospecs = @_;
     my @res;
     my $i = 0;
     for my $ospec (@ospecs) {
         my $j = 0;
         my $parsed = $ospec->{parsed};
         for (@{ $parsed->{opts} }) {
             my $opt = _dash_prefix($_);
             if ($i==0 && $j==0) {
                 if ($parsed->{type}) {
                     if ($spec->{'x.schema.entity'}) {
                         $opt .= "=".$spec->{'x.schema.entity'};
                     } elsif ($spec->{'x.schema.element_entity'}) {
                         $opt .= "=".$spec->{'x.schema.element_entity'};
                     } else {
                         $opt .= "=$parsed->{type}";
                     }
                 }
                 $opt .= "*" if $spec->{req} && !$ospec->{is_base64} &&
                     !$ospec->{is_json} && !$ospec->{is_yaml};
             }
             push @res, $opt;
             $j++;
         }
         $i++;
     }
     join ", ", @res;
 }
 
 $SPEC{gen_cli_doc_data_from_meta} = {
     v => 1.1,
     summary => 'From Rinci function metadata, generate structure convenient '.
         'for producing CLI documentation (help/usage/POD)',
     description => <<'_',
 
 This function calls `Perinci::Sub::GetArgs::Argv`'s
 `gen_getopt_long_spec_from_meta()` (or receive its result as an argument, if
 passed, to avoid calling the function twice) and post-processes it: produce
 command usage line, format the options, include information from metadata, group
 the options by category. It also selects examples in the `examples` property
 which are applicable to CLI environment and format them.
 
 The resulting data structure is convenient to use when one wants to produce a
 documentation for CLI program (including help/usage message and POD).
 
 _
     args => {
         meta => {
             schema => 'hash*', 
             req => 1,
             pos => 0,
         },
         meta_is_normalized => {
             schema => 'bool*',
         },
         common_opts => {
             summary => 'Will be passed to gen_getopt_long_spec_from_meta()',
             schema  => 'hash*',
         },
         ggls_res => {
             summary => 'Full result from gen_getopt_long_spec_from_meta()',
             schema  => 'array*', 
             description => <<'_',
 
 If you already call `Perinci::Sub::GetArgs::Argv`'s
 `gen_getopt_long_spec_from_meta()`, you can pass the _full_ enveloped result
 here, to avoid calculating twice. What will be useful for the function is the
 extra result in result metadata (`func.*` keys in `$res->[3]` hash).
 
 _
         },
         per_arg_json => {
             schema => 'bool',
             summary => 'Pass per_arg_json=1 to Perinci::Sub::GetArgs::Argv',
         },
         per_arg_yaml => {
             schema => 'bool',
             summary => 'Pass per_arg_json=1 to Perinci::Sub::GetArgs::Argv',
         },
         lang => {
             schema => 'str*',
         },
     },
     result => {
         schema => 'hash*',
     },
 };
 sub gen_cli_doc_data_from_meta {
     require Getopt::Long::Negate::EN;
 
     my %args = @_;
 
     my $lang = $args{lang};
     my $meta = $args{meta} or return [400, 'Please specify meta'];
     my $common_opts = $args{common_opts};
     unless ($args{meta_is_normalized}) {
         require Perinci::Sub::Normalize;
         $meta = Perinci::Sub::Normalize::normalize_function_metadata($meta);
     }
     my $ggls_res = $args{ggls_res} // do {
         require Perinci::Sub::GetArgs::Argv;
         Perinci::Sub::GetArgs::Argv::gen_getopt_long_spec_from_meta(
             meta=>$meta, meta_is_normalized=>1, common_opts=>$common_opts,
             per_arg_json => $args{per_arg_json},
             per_arg_yaml => $args{per_arg_yaml},
         );
     };
     $ggls_res->[0] == 200 or return $ggls_res;
 
     my $args_prop = $meta->{args} // {};
     my $clidocdata = {
         option_categories => {},
         example_categories => {},
     };
 
     {
         my @args;
         my %args_prop = %$args_prop; 
         my $max_pos = -1;
         for (values %args_prop) {
             $max_pos = $_->{pos}
                 if defined($_->{pos}) && $_->{pos} > $max_pos;
         }
         my $pos = 0;
         while ($pos <= $max_pos) {
             my ($arg, $arg_spec);
             for (keys %args_prop) {
                 $arg_spec = $args_prop{$_};
                 if (defined($arg_spec->{pos}) && $arg_spec->{pos}==$pos) {
                     $arg = $_;
                     last;
                 }
             }
             $pos++;
             next unless defined($arg);
             if ($arg_spec->{req}) {
                 push @args, "<$arg>";
             } else {
                 push @args, "[$arg]";
             }
             $args[-1] .= "..." if $arg_spec->{greedy};
             delete $args_prop{$arg};
         }
         unshift @args, "[options]" if keys(%args_prop) || keys(%$common_opts); 
         $clidocdata->{usage_line} = "[[prog]]".
             (@args ? " ".join(" ", @args) : "");
     }
 
     my %opts;
     {
         my $ospecs = $ggls_res->[3]{'func.specmeta'};
         my (@k, @k_aliases);
       OSPEC1:
         for (sort keys %$ospecs) {
             my $ospec = $ospecs->{$_};
             {
                 last unless $ospec->{is_alias};
                 next if $ospec->{is_code};
                 my $arg_spec = $args_prop->{$ospec->{arg}};
                 my $alias_spec = $arg_spec->{cmdline_aliases}{$ospec->{alias}};
                 next if $alias_spec->{summary};
                 push @k_aliases, $_;
                 next OSPEC1;
             }
             push @k, $_;
         }
 
         my %negs; 
 
       OSPEC2:
         while (@k) {
             my $k = shift @k;
             my $ospec = $ospecs->{$k};
             my $opt;
             my $optkey;
 
             if ($ospec->{is_alias} || defined($ospec->{arg})) {
                 my $arg_spec;
                 my $alias_spec;
 
                 if ($ospec->{is_alias}) {
 
                     $arg_spec = $args_prop->{ $ospec->{arg} };
                     $alias_spec = $arg_spec->{cmdline_aliases}{$ospec->{alias}};
                     my $rimeta = rimeta($alias_spec);
                     $optkey = _fmt_opt($arg_spec, $ospec);
                     $opt = {
                         opt_parsed => $ospec->{parsed},
                         orig_opt => $k,
                         is_alias => 1,
                         alias_for => $ospec->{alias_for},
                         summary => $rimeta->langprop({lang=>$lang}, 'summary') //
                             "Alias for "._dash_prefix($ospec->{parsed}{opts}[0]),
                         description =>
                             $rimeta->langprop({lang=>$lang}, 'description'),
                     };
                 } else {
 
                     $arg_spec = $args_prop->{$ospec->{arg}};
                     my $rimeta = rimeta($arg_spec);
                     $opt = {
                         opt_parsed => $ospec->{parsed},
                         orig_opt => $k,
                     };
 
                     if (defined($ospec->{is_neg})) {
                         my $default = $arg_spec->{default} //
                             $arg_spec->{schema}[1]{default};
                         next OSPEC2 if  $default && !$ospec->{is_neg};
                         next OSPEC2 if !$default &&  $ospec->{is_neg};
                         if ($ospec->{is_neg}) {
                             next OSPEC2 if $negs{$ospec->{arg}}++;
                         }
                     }
 
                     if ($ospec->{is_neg}) {
                         $opt->{summary} =
                             $rimeta->langprop({lang=>$lang}, 'summary.alt.bool.not');
                     } elsif (defined $ospec->{is_neg}) {
                         $opt->{summary} =
                             $rimeta->langprop({lang=>$lang}, 'summary.alt.bool.yes') //
                                 $rimeta->langprop({lang=>$lang}, 'summary');
                     } elsif (($ospec->{parsed}{type}//'') eq 's@') {
                         $opt->{summary} =
                             $rimeta->langprop({lang=>$lang}, 'summary.alt.plurality.singular') //
                                 $rimeta->langprop({lang=>$lang}, 'summary');
                     } else {
                         $opt->{summary} =
                             $rimeta->langprop({lang=>$lang}, 'summary');
                     }
                     $opt->{description} =
                         $rimeta->langprop({lang=>$lang}, 'description');
 
                     my @aliases;
                     my $j = $#k_aliases;
                     while ($j >= 0) {
                         my $aospec = $ospecs->{ $k_aliases[$j] };
                         {
                             last unless $aospec->{arg} eq $ospec->{arg};
                             push @aliases, $aospec;
                             splice @k_aliases, $j, 1;
                         }
                         $j--;
                     }
 
                     $optkey = _fmt_opt($arg_spec, $ospec, @aliases);
                 }
 
                 $opt->{arg_spec} = $arg_spec;
                 $opt->{alias_spec} = $alias_spec if $alias_spec;
 
                 for (qw/arg fqarg is_base64 is_json is_yaml/) {
                     $opt->{$_} = $ospec->{$_} if defined $ospec->{$_};
                 }
 
                 for (qw/req pos greedy is_password links tags/) {
                     $opt->{$_} = $arg_spec->{$_} if defined $arg_spec->{$_};
                 }
 
                 _add_category_from_spec($clidocdata->{option_categories},
                                         $opt, $arg_spec, "options", 1);
                 _add_default_from_arg_spec($opt, $arg_spec);
 
             } else {
 
                 my $spec = $common_opts->{$ospec->{common_opt}};
 
                 my $show_neg = $ospec->{parsed}{is_neg} && $spec->{default};
 
                 local $ospec->{parsed}{opts} = do {
                     my @opts = Getopt::Long::Negate::EN::negations_for_option(
                         $ospec->{parsed}{opts}[0]);
                     [ $opts[0] ];
                 } if $show_neg;
 
                 $optkey = _fmt_opt($spec, $ospec);
                 my $rimeta = rimeta($spec);
                 $opt = {
                     opt_parsed => $ospec->{parsed},
                     orig_opt => $k,
                     common_opt => $ospec->{common_opt},
                     common_opt_spec => $spec,
                     summary => $show_neg ?
                         $rimeta->langprop({lang=>$lang}, 'summary.alt.bool.not') :
                             $rimeta->langprop({lang=>$lang}, 'summary'),
                     (schema => $spec->{schema}) x !!$spec->{schema},
                     ('x.schema.entity' => $spec->{'x.schema.entity'}) x !!$spec->{'x.schema.entity'},
                     ('x.schema.element_entity' => $spec->{'x.schema.element_entity'}) x !!$spec->{'x.schema.element_entity'},
                     description =>
                         $rimeta->langprop({lang=>$lang}, 'description'),
                     (default => $spec->{default}) x !!(exists($spec->{default}) && !$show_neg),
                 };
 
                 _add_category_from_spec($clidocdata->{option_categories},
                                         $opt, $spec, "options", 1);
 
             }
 
             $opts{$optkey} = $opt;
         }
 
       OPT1:
         for my $k (keys %opts) {
             my $opt = $opts{$k};
             next unless $opt->{is_alias} || $opt->{is_base64} ||
                 $opt->{is_json} || $opt->{is_yaml};
             for my $k2 (keys %opts) {
                 my $arg_opt = $opts{$k2};
                 next if $arg_opt->{is_alias} || $arg_opt->{is_base64} ||
                     $arg_opt->{is_json} || $arg_opt->{is_yaml};
                 next unless defined($arg_opt->{arg}) &&
                     $arg_opt->{arg} eq $opt->{arg};
                 $opt->{main_opt} = $k2;
                 next OPT1;
             }
         }
 
     }
     $clidocdata->{opts} = \%opts;
 
     my @examples;
     {
         my $examples = $meta->{examples} // [];
         my $has_cats = _has_cats($examples);
 
         for my $eg (@$examples) {
             my $rimeta = rimeta($eg);
             my $argv;
             my $cmdline;
             if (defined($eg->{src})) {
                 if ($eg->{src_plang} =~ /^(sh|bash)$/) {
                     $cmdline = $eg->{src};
                 } else {
                     next;
                 }
             } else {
                 require String::ShellQuote;
                 if ($eg->{argv}) {
                     $argv = $eg->{argv};
                 } else {
                     require Perinci::Sub::ConvertArgs::Argv;
                     my $res = Perinci::Sub::ConvertArgs::Argv::convert_args_to_argv(
                         args => $eg->{args}, meta => $meta);
                     return err($res, 500, "Can't convert args to argv")
                         unless $res->[0] == 200;
                     $argv = $res->[2];
                 }
                 $cmdline = "[[prog]]";
                 for my $arg (@$argv) {
                     my $qarg = String::ShellQuote::shell_quote($arg);
                     $cmdline .= " $qarg"; 
                 }
             }
             my $egdata = {
                 cmdline      => $cmdline,
                 summary      => $rimeta->langprop({lang=>$lang}, 'summary'),
                 description  => $rimeta->langprop({lang=>$lang}, 'description'),
                 example_spec => $eg,
             };
             _add_category_from_spec($clidocdata->{example_categories},
                                     $egdata, $eg, "examples", $has_cats);
             push @examples, $egdata;
         }
     }
     $clidocdata->{examples} = \@examples;
 
     [200, "OK", $clidocdata];
 }
 
 1;
 
 __END__
 
### Perinci/Sub/Util.pm ###
 package Perinci::Sub::Util;
 
 our $DATE = '2015-09-04'; 
 our $VERSION = '0.42'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        err
                        caller
                        gen_modified_sub
                        warn_err
                        die_err
                );
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'Helper when writing functions',
 };
 
 our $STACK_TRACE;
 our @_c; 
 our $_i; 
 sub err {
     require Scalar::Util;
 
     my @caller = CORE::caller(1);
     if (!@caller) {
         @caller = ("main", "-e", 1, "program");
     }
 
     my ($status, $msg, $meta, $prev);
 
     for (@_) {
         my $ref = ref($_);
         if ($ref eq 'ARRAY') { $prev = $_ }
         elsif ($ref eq 'HASH') { $meta = $_ }
         elsif (!$ref) {
             if (Scalar::Util::looks_like_number($_)) {
                 $status = $_;
             } else {
                 $msg = $_;
             }
         }
     }
 
     $status //= 500;
     $msg  //= "$caller[3] failed";
     $meta //= {};
     $meta->{prev} //= $prev if $prev;
 
     if (!$meta->{logs}) {
 
         my $stack_trace;
         {
             no warnings;
             last unless $STACK_TRACE // $INC{"Carp/Always.pm"};
             last if $prev && ref($prev->[3]) eq 'HASH' &&
                 ref($prev->[3]{logs}) eq 'ARRAY' &&
                     ref($prev->[3]{logs}[0]) eq 'HASH' &&
                         $prev->[3]{logs}[0]{stack_trace};
             $stack_trace = [];
             $_i = 1;
             while (1) {
                 {
                     package DB;
                     @_c = CORE::caller($_i);
                     if (@_c) {
                         $_c[4] = [@DB::args];
                     }
                 }
                 last unless @_c;
                 push @$stack_trace, [@_c];
                 $_i++;
             }
         }
         push @{ $meta->{logs} }, {
             type    => 'create',
             time    => time(),
             package => $caller[0],
             file    => $caller[1],
             line    => $caller[2],
             func    => $caller[3],
             ( stack_trace => $stack_trace ) x !!$stack_trace,
         };
     }
 
     [$status, $msg, undef, $meta];
 }
 
 sub caller {
     my $n0 = shift;
     my $n  = $n0 // 0;
 
     my $pkg = $Perinci::Sub::Wrapper::default_wrapped_package //
         'Perinci::Sub::Wrapped';
 
     my @r;
     my $i =  0;
     my $j = -1;
     while ($i <= $n+1) { 
         $j++;
         @r = CORE::caller($j);
         last unless @r;
         if ($r[0] eq $pkg && $r[1] =~ /^\(eval /) {
             next;
         }
         $i++;
     }
 
     return unless @r;
     return defined($n0) ? @r : $r[0];
 }
 
 $SPEC{gen_modified_sub} = {
     v => 1.1,
     summary => 'Generate modified metadata (and subroutine) based on another',
     description => <<'_',
 
 Often you'll want to create another sub (and its metadata) based on another, but
 with some modifications, e.g. add/remove/rename some arguments, change summary,
 add/remove some properties, and so on.
 
 Instead of cloning the Rinci metadata and modify it manually yourself, this
 routine provides some shortcuts.
 
 You can specify base sub/metadata using `base_name` (string, subroutine name,
 either qualified or not) or `base_code` (coderef) + `base_meta` (hash).
 
 _
     args => {
         base_name => {
             summary => 'Subroutine name (either qualified or not)',
             schema => 'str*',
             description => <<'_',
 
 If not qualified with package name, will be searched in the caller's package.
 Rinci metadata will be searched in `%SPEC` package variable.
 
 Alternatively, you can also specify `base_code` and `base_meta`.
 
 _
         },
         base_code => {
             summary => 'Base subroutine code',
             schema  => 'code*',
             description => <<'_',
 
 If you specify this, you'll also need to specify `base_meta`.
 
 Alternatively, you can specify `base_name` instead, to let this routine search
 the base subroutine from existing Perl package.
 
 _
         },
         base_meta => {
             summary => 'Base Rinci metadata',
             schema  => 'hash*', 
         },
         output_name => {
             summary => 'Where to install the modified sub',
             schema  => 'str*',
             description => <<'_',
 
 Subroutine will be put in the specified name. If the name is not qualified with
 package name, will use caller's package. If no `output_code` is specified, the
 base subroutine reference will be assigned here.
 
 Note that this argument is optional.
 
 _
         },
         output_code => {
             summary => 'Code for the modified sub',
             schema  => 'code*',
             description => <<'_',
 
 If not specified will use `base_code` (which will then be required).
 
 _
         },
         summary => {
             summary => 'Summary for the mod subroutine',
             schema  => 'str*',
         },
         description => {
             summary => 'Description for the mod subroutine',
             schema  => 'str*',
         },
         remove_args => {
             summary => 'List of arguments to remove',
             schema  => 'array*',
         },
         add_args => {
             summary => 'Arguments to add',
             schema  => 'hash*',
         },
         replace_args => {
             summary => 'Arguments to add',
             schema  => 'hash*',
         },
         rename_args => {
             summary => 'Arguments to rename',
             schema  => 'hash*',
         },
         modify_args => {
             summary => 'Arguments to modify',
             description => <<'_',
 
 For each argument you can specify a coderef. The coderef will receive the
 argument ($arg_spec) and is expected to modify the argument specification.
 
 _
             schema  => 'hash*',
         },
         modify_meta => {
             summary => 'Specify code to modify metadata',
             schema  => 'code*',
             description => <<'_',
 
 Code will be called with arguments ($meta) where $meta is the cloned Rinci
 metadata.
 
 _
         },
         install_sub => {
             schema  => 'bool',
             default => 1,
         },
     },
     result => {
         schema => ['hash*' => {
             keys => {
                 code => ['code*'],
                 meta => ['hash*'], 
             },
         }],
     },
 };
 sub gen_modified_sub {
     require Function::Fallback::CoreOrPP;
 
     my %args = @_;
 
     my ($base_code, $base_meta);
     if ($args{base_name}) {
         my ($pkg, $leaf);
         if ($args{base_name} =~ /(.+)::(.+)/) {
             ($pkg, $leaf) = ($1, $2);
         } else {
             $pkg  = CORE::caller();
             $leaf = $args{base_name};
         }
         no strict 'refs';
         $base_code = \&{"$pkg\::$leaf"};
         $base_meta = ${"$pkg\::SPEC"}{$leaf};
         die "Can't find Rinci metadata for $pkg\::$leaf" unless $base_meta;
     } elsif ($args{base_meta}) {
         $base_meta = $args{base_meta};
         $base_code = $args{base_code}
             or die "Please specify base_code";
     } else {
         die "Please specify base_name or base_code+base_meta";
     }
 
     my $output_meta = Function::Fallback::CoreOrPP::clone($base_meta);
     my $output_code = $args{output_code} // $base_code;
 
     for (qw/summary description/) {
         $output_meta->{$_} = $args{$_} if $args{$_};
     }
     if ($args{remove_args}) {
         delete $output_meta->{args}{$_} for @{ $args{remove_args} };
     }
     if ($args{add_args}) {
         for my $k (keys %{ $args{add_args} }) {
             my $v = $args{add_args}{$k};
             die "Can't add arg '$k' in mod sub: already exists"
                 if $output_meta->{args}{$k};
             $output_meta->{args}{$k} = $v;
         }
     }
     if ($args{replace_args}) {
         for my $k (keys %{ $args{replace_args} }) {
             my $v = $args{replace_args}{$k};
             die "Can't replace arg '$k' in mod sub: doesn't exist"
                 unless $output_meta->{args}{$k};
             $output_meta->{args}{$k} = $v;
         }
     }
     if ($args{rename_args}) {
         for my $old (keys %{ $args{rename_args} }) {
             my $new = $args{rename_args}{$old};
             my $as = $output_meta->{args}{$old};
             die "Can't rename arg '$old' in mod sub: doesn't exist" unless $as;
             die "Can't rename arg '$old'->'$new' in mod sub: ".
                 "new name already exist" if $output_meta->{args}{$new};
             $output_meta->{args}{$new} = $as;
             delete $output_meta->{args}{$old};
         }
     }
     if ($args{modify_args}) {
         for (keys %{ $args{modify_args} }) {
             $args{modify_args}{$_}->($output_meta->{args}{$_});
         }
     }
     if ($args{modify_meta}) {
         $args{modify_meta}->($output_meta);
     }
 
     if ($args{output_name}) {
         my ($pkg, $leaf);
         if ($args{output_name} =~ /(.+)::(.+)/) {
             ($pkg, $leaf) = ($1, $2);
         } else {
             $pkg  = CORE::caller();
             $leaf = $args{output_name};
         }
         no strict 'refs';
         no warnings 'redefine';
         *{"$pkg\::$leaf"}       = $output_code if $args{install_sub} // 1;
         ${"$pkg\::SPEC"}{$leaf} = $output_meta;
     }
 
     [200, "OK", {code=>$output_code, meta=>$output_meta}];
 }
 
 
 sub warn_err {
     require Carp;
 
     my $res = err(@_);
     Carp::carp("ERROR $res->[0]: $res->[1]");
 }
 
 sub die_err {
     require Carp;
 
     my $res = err(@_);
     Carp::croak("ERROR $res->[0]: $res->[1]");
 }
 
 1;
 
 __END__
 
### Perinci/Sub/Util/ResObj.pm ###
 package Perinci::Sub::Util::ResObj;
 
 our $DATE = '2015-09-04'; 
 our $VERSION = '0.42'; 
 
 use Carp;
 use overload
     q("") => sub {
         my $res = shift; "ERROR $err->[0]: $err->[1]\n" . Carp::longmess();
     };
 
 1;
 
 __END__
 
### Perinci/Sub/Util/Sort.pm ###
 package Perinci::Sub::Util::Sort;
 
 our $DATE = '2015-09-04'; 
 our $VERSION = '0.42'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        sort_args
                );
 
 our %SPEC;
 
 sub sort_args {
     my $args = shift;
     sort {
         (($args->{$a}{pos} // 9999) <=> ($args->{$b}{pos} // 9999)) ||
             $a cmp $b
         } keys %$args;
 }
 
 1;
 
 __END__
 
### Perinci/Sub/Wrapper.pm ###
 package Perinci::Sub::Wrapper;
 
 our $DATE = '2015-09-04'; 
 our $VERSION = '0.79'; 
 
 use 5.010001;
 use strict;
 use warnings;
 use experimental 'smartmatch';
 use Log::Any::IfLOG '$log';
 
 use Function::Fallback::CoreOrPP qw(clone);
 use Perinci::Sub::Normalize qw(normalize_function_metadata);
 use Perinci::Sub::Util qw(err);
 
 use Exporter qw(import);
 our @EXPORT_OK = qw(wrap_sub);
 
 our $Log_Wrapper_Code = $ENV{LOG_PERINCI_WRAPPER_CODE} // 0;
 
 our %SPEC;
 
 $SPEC{':package'} = {
     v => 1.1,
     summary => 'A multi-purpose subroutine wrapping framework',
 };
 
 our $protocol_version = 2;
 
 sub new {
     my ($class) = @_;
     bless {}, $class;
 }
 
 sub __squote {
     require Data::Dumper;
     my $res = Data::Dumper->new([shift])->
         Purity(1)->Terse(1)->Deepcopy(1)->Indent(0)->Dump;
     chomp $res;
     $res;
 }
 
 sub _check_module {
     my ($self, $mod) = @_;
 
     if ($self->{_args}{core}) {
         if ($mod =~ /\A(experimental|Scalar::Numeric::Util|Scalar::Util::Numeric::PP)\z/) {
             die "BUG: Requested non-core module '$mod' while wrap arg core=1";
         } elsif ($mod =~ /\A(warnings|List::Util)\z/) {
         } else {
             die "BUG: Haven't noted whether module '$mod' is core/non-core";
         }
     }
 
     if ($self->{_args}{pp}) {
         if ($mod =~ /\A(List::Util|Scalar::Numeric::Util)\z/) {
             die "BUG: Requested XS module '$mod' while wrap arg pp=1";
         } elsif ($mod =~ /\A(experimental|warnings|Scalar::Util::Numeric::PP)\z/) {
         } else {
             die "BUG: Haven't noted whether module '$mod' is pure-perl/XS";
         }
     }
 
     if ($self->{_args}{core_or_pp}) {
         if ($mod =~ /\A(Scalar::Numeric::Util)\z/) {
             die "BUG: Requested non-core XS module '$mod' while wrap arg core_or_pp=1";
         } elsif ($mod =~ /\A(experimental|warnings|List::Util|Scalar::Util::Numeric::PP)\z/) {
         } else {
             die "BUG: Haven't noted whether module '$mod' is non-core xs or not";
         }
     }
 }
 
 sub _add_module {
     my ($self, $mod) = @_;
     unless ($mod ~~ $self->{_modules}) {
         local $self->{_cur_section};
         $self->select_section('before_sub_require_modules');
         if ($mod =~ /(-?)(.+?)\s+(.+)/) {
             $self->_check_module($2);
             if ($1) {
                 $self->push_lines("no $2 $3;");
             } else {
                 $self->push_lines("use $2 $3;");
             }
         } else {
             $self->_check_module($mod);
             $self->push_lines("require $mod;");
         }
         push @{ $self->{_modules} }, $mod;
     }
 }
 
 sub _add_modules {
     my ($self, $mods) = @_;
     for my $mod (sort keys %$mods) {
         my $modspec = $mods->{$mod};
         if ($modspec->[1]) {
             if ($modspec->[0] eq 'no') {
                 $self->_add_module("-$mod ".join(" ", @{ $modspec->[1] }));
             } else {
                 $self->_add_module( "$mod ".join(" ", @{ $modspec->[1] }));
             }
         } else {
             $self->_add_module($mod);
         }
     }
 }
 
 sub _add_var {
     my ($self, $var, $value) = @_;
     unless (exists $self->{_vars}{$var}) {
         local $self->{_cur_section};
         $self->select_section('declare_vars');
         $self->push_lines("my \$$var = ".__squote($value).";");
         $self->{_vars}{$var} = $value;
     }
 }
 
 sub _known_sections {
 
 
     state $val = {
         before_sub_require_modules => {order=>1},
 
         OPEN_SUB => {order=>4},
 
         ACCEPT_ARGS => {order=>5},
 
         ACCEPT_ARGS2 => {order=>6},
 
         declare_vars => {order=>7},
 
         before_eval => {order=>10},
 
         OPEN_EVAL => {order=>20},
 
         before_call_before_arg_validation => {order=>31},
 
         before_call_arg_validation => {order=>32},
 
         before_call_after_arg_validation => {order=>33},
 
         before_call_feed_args => {order=>48},
 
         before_call_right_before_call => {order=>49},
 
         CALL => {order=>50},
 
         after_call_right_after_call => {order=>51},
 
         AFTER_CALL_ADD_OR_STRIP_RESULT_ENVELOPE => {order=>52},
 
         after_call_before_res_validation => {order=>61},
 
         after_call_res_validation => {order=>62},
 
         after_call_after_res_validation => {order=>63},
 
         CLOSE_EVAL => {order=>70},
 
         after_eval => {order=>80},
 
         BEFORE_CLOSE_SUB => {order=>99},
 
         CLOSE_SUB => {order=>100},
     };
     $val;
 }
 
 sub section_empty {
     my ($self, $section) = @_;
     !$self->{_codes}{$section};
 }
 
 sub _needs_eval {
     my ($self) = @_;
     !($self->section_empty('before_eval') &&
           $self->section_empty('after_eval'));
 }
 
 sub _needs_store_res {
     my ($self) = @_;
     return 1 if $self->{_args}{validate_result};
     return 1 if $self->_needs_eval;
     my $ks = $self->_known_sections;
     for (grep {/^after_call/} keys %$ks) {
         return 1 unless $self->section_empty($_);
     }
     0;
 }
 
 sub _check_known_section {
     my ($self, $section) = @_;
     my $ks = $self->_known_sections;
     $ks->{$section} or die "BUG: Unknown code section '$section'";
 }
 
 sub _err {
     my ($self, $c_status, $c_msg) = @_;
     if ($self->{_meta}{result_naked}) {
         $self->push_lines(
             "warn 'ERROR ' . ($c_status) . ': '. ($c_msg);",
             'return undef;',
         );
     } else {
         $self->push_lines("return [$c_status, $c_msg];");
     }
 }
 
 sub _errif {
     my ($self, $c_status, $c_msg, $c_cond) = @_;
     $self->push_lines("if ($c_cond) {");
     $self->indent;
     $self->_err($c_status, $c_msg);
     $self->unindent;
     $self->push_lines('}');
 }
 
 sub select_section {
     my ($self, $section) = @_;
     $self->_check_known_section($section);
     $self->{_cur_section} = $section;
     $self;
 }
 
 sub indent {
     my ($self) = @_;
     my $section = $self->{_cur_section};
     $self->{_codes}{$section} //= undef;
     $self->{_levels}{$section}++;
     $self;
 }
 
 sub unindent {
     my ($self) = @_;
     my $section = $self->{_cur_section};
     $self->{_codes}{$section} //= undef;
     $self->{_levels}{$section}--;
     $self;
 }
 
 sub get_indent_level {
     my ($self) = @_;
     my $section = $self->{_cur_section};
     $self->{_levels}{$section} // 0;
 }
 
 
 sub push_lines {
     my ($self, @lines) = @_;
     my $section = $self->{_cur_section};
 
     unless (exists $self->{_codes}{$section}) {
         unshift @lines, "# * section: $section";
         unshift @lines, "" if $self->_known_sections->{$section}{order};
         $self->{_codes}{$section} = [];
         $self->{_levels}{$section} = 0;
     }
 
     @lines = map {[$self->{_levels}{$section}, $_]} @lines;
     if ($self->{_args}{debug}) {
         for my $l (@lines) {
             $l->[2] =
                 $self->{_cur_handler} ?
                     "$self->{_cur_handler} prio=".$self->{_cur_handler_meta}{prio}
                         : "";
         }
     }
     push @{$self->{_codes}{$section}}, @lines;
     $self;
 }
 
 sub _join_codes {
     my ($self, $crit, $prev_section_level) = @_;
     my @lines;
     my $ks = $self->_known_sections;
     $prev_section_level //= 0;
     my $i = 0;
     for my $s (sort {$ks->{$a}{order} <=> $ks->{$b}{order}}
                    keys %$ks) {
         next if $self->section_empty($s);
         next unless $crit->(section => $s);
         $i++;
         for my $l (@{ $self->{_codes}{$s} }) {
             $l->[0] += $prev_section_level;
             die "BUG: Negative indent level in line $i (section $s): '$l->[1]'"
                 if $l->[0] < 0;
             my $s = ($self->{_args}{indent} x $l->[0]) . $l->[1];
             if (defined $l->[2]) {
                 my $num_ws = 80 - length($s);
                 $num_ws = 1 if $num_ws < 1;
                 $s .= (" " x $num_ws) . "## $l->[2]";
             }
             push @lines, $s;
         }
         $prev_section_level += $self->{_levels}{$s};
     }
     [join("\n", @lines), $prev_section_level];
 }
 
 sub _format_dyn_wrapper_code {
     my ($self) = @_;
     my $ks = $self->_known_sections;
     $self->_join_codes(
         sub {
             my %args = @_;
             my $section = $args{section};
             !$ks->{$section}{embed};
         })->[0];
 }
 
 sub _format_embed_wrapper_code {
     my ($self) = @_;
 
     my $res = {};
     my $ks = $self->_known_sections;
     my $j;
 
     $j = $self->_join_codes(
         sub {
             my %args = @_;
             my $section = $args{section};
             $section =~ /\A(before_sub_require_modules)\z/;
         });
     $res->{presub1} = $j->[0];
 
     $res->{presub2} = '';
 
     $j = $self->_join_codes(
         sub {
             my %args = @_;
             my $section = $args{section};
             my $order = $ks->{$section}{order};
             return 1 if $order > $ks->{ACCEPT_ARGS}{order} &&
                 $order < $ks->{CALL}{order};
             0;
         }, 1);
     $res->{preamble} = $j->[0];
 
     $j = $self->_join_codes(
         sub {
             my %args = @_;
             my $section = $args{section};
             my $order = $ks->{$section}{order};
             return 1 if $order > $ks->{CALL}{order} &&
                 $order < $ks->{CLOSE_SUB}{order};
             0;
         }, $j->[1]);
     $res->{postamble} = $j->[0];
 
     $res;
 }
 
 sub handlemeta_v { {} }
 sub handlemeta_name { {} }
 sub handlemeta_summary { {} }
 sub handlemeta_description { {} }
 sub handlemeta_tags { {} }
 sub handlemeta_default_lang { {} }
 sub handlemeta_links { {} }
 sub handlemeta_text_markup { {} }
 sub handlemeta_is_func { {} }
 sub handlemeta_is_meth { {} }
 sub handlemeta_is_class_meth { {} }
 sub handlemeta_examples { {} }
 
 sub handlemeta_features { {v=>2, prio=>15} }
 sub handle_features {
     my ($self, %args) = @_;
 
     my $meta = $self->{_meta};
     my $v = $meta->{features} // {};
 
     $self->select_section('before_call_before_arg_validation');
 
     if ($v->{tx} && $v->{tx}{req}) {
         $self->push_lines('', '# check required transaction');
         $self->_errif(412, '"Must run with transaction (pass -tx_manager)"',
                       '!$args{-tx_manager}');
     }
 }
 
 sub handlemeta_args_as { {v=>2, prio=>1, convert=>1} }
 sub handle_args_as {
     my ($self, %args) = @_;
 
     my $value  = $args{value};
     my $new    = $args{new};
     my $meta   = $self->{_meta};
     my $args_p = $meta->{args} // {};
     my $opt_va = $self->{_args}{validate_args};
 
 
     my $v = $new // $value;
 
     $self->select_section('ACCEPT_ARGS');
     if ($v eq 'hash') {
          $self->push_lines(q{die 'BUG: Odd number of hash elements supplied' if @_ % 2;})
              if $opt_va;
          $self->push_lines('my %args = @_;');
     } elsif ($v eq 'hashref') {
         $self->push_lines(q{die 'BUG: $_[0] needs to be hashref' if @_ && ref($_[0]) ne "HASH";})
             if $opt_va;
         $self->push_lines('my %args = %{$_[0] // {}};');
     } elsif ($v =~ /\Aarray(ref)?\z/) {
         my $ref = $1 ? 1:0;
         if ($ref) {
             $self->push_lines(q{die 'BUG: $_[0] needs to be arrayref' if @_ && ref($_[0]) ne "ARRAY";})
                 if $opt_va;
         }
         $self->push_lines('my %args;');
         $self->select_section('ACCEPT_ARGS2');
         for my $a (sort keys %$args_p) {
             my $as = $args_p->{$a};
             my $line = '$args{'.__squote($a).'} = ';
             defined($as->{pos}) or die "Error in args property for arg '$a': ".
                 "no pos defined";
             my $pos = int($as->{pos} + 0);
             $pos >= 0 or die "Error in args property for arg '$a': ".
                 "negative value in pos";
             if ($as->{greedy}) {
                 if ($ref) {
                     $line .= '[splice @{$_[0]}, '.$pos.'] if @{$_[0]} > '.$pos;
                 } else {
                     $line .= '[splice @_, '.$pos.'] if @_ > '.$pos;
                 }
             } else {
                 if ($ref) {
                     $line .= '$_[0]['.$pos.'] if @{$_[0]} > '.$pos;
                 } else {
                     $line .= '$_['.$pos.'] if @_ > '.$pos;
                 }
             }
             $self->push_lines("$line;");
         }
     } else {
         die "Unknown args_as value '$v'";
     }
 
     $self->select_section('ACCEPT_ARGS');
     if ($value eq 'hashref') {
         $self->push_lines('my $args;');
     } elsif ($value eq 'array') {
         $self->push_lines('my @args;');
     } elsif ($value eq 'arrayref') {
         $self->push_lines('my $args;');
     }
 
     my $tok;
     $self->select_section('before_call_feed_args');
     $v = $value;
     if ($v eq 'hash') {
         $tok = '%args';
     } elsif ($v eq 'hashref') {
         $tok = '$args';
         $self->push_lines($tok.' = \%args;'); 
     } elsif ($v =~ /\Aarray(ref)?\z/) {
         my $ref = $1 ? 1:0;
         $tok = ($ref ? '$':'@') . 'args';
         for my $a (sort {$args_p->{$a}{pos} <=> $args_p->{$b}{pos}}
                        keys %$args_p) {
             my $as = $args_p->{$a};
             my $t = '$args{'.__squote($a).'}';
             my $line;
             defined($as->{pos}) or die "Error in args property for arg '$a': ".
                 "no pos defined";
             my $pos = int($as->{pos} + 0);
             $pos >= 0 or die "Error in args property for arg '$a': ".
                 "negative value in pos";
             if ($as->{greedy}) {
                 $line = 'splice @args, '.$pos.', scalar(@args)-1, @{'.$t.'}';
             } else {
                 $line = '$args'.($ref ? '->':'').'['.$pos."] = $t if exists $t";
             }
             $self->push_lines("$line;");
         }
     } else {
         die "Unknown args_as value '$v'";
     }
     $self->{_args_token} = $tok;
 }
 
 sub _sah {
     require Data::Sah;
 
     my $self = shift;
     state $sah = Data::Sah->new;
     $sah;
 }
 
 sub _plc {
     my $self = shift;
     state $plc = do {
         my $plc = $self->_sah->get_compiler("perl");
         $plc->comment_style('shell2'); 
         $plc;
     };
 }
 
 sub _handle_args {
     my ($self, %args) = @_;
 
     my $v = $args{v} // $self->{_meta}{args};
     return unless $v;
 
     my $opt_sin = $self->{_args}{_schema_is_normalized};
     my $opt_va  = $self->{_args}{validate_args};
 
     my $prefix = $args{prefix} // '';
     my $argsterm = $args{argsterm} // '%args';
 
     if ($opt_va) {
         $self->_add_module("experimental 'smartmatch'");
         $self->select_section('before_call_arg_validation');
         $self->push_lines('', '# check args') if $prefix eq '';
         $self->push_lines("for (sort keys $argsterm) {");
         $self->indent;
         $self->_errif(400, q["Invalid argument name (please use letters/numbers/underscores only)'].$prefix.q[$_'"],
                       '!/\A(-?)\w+(\.\w+)*\z/o');
         $self->_errif(400, q["Unknown argument '].$prefix.q[$_'"],
                       '!($1 || $_ ~~ '.__squote([sort keys %$v]).')');
         $self->unindent;
         $self->push_lines('}');
     }
 
     for my $argname (sort keys %$v) {
         my $argspec = $v->{$argname};
 
         my $argterm = $argsterm;
         if ($argterm =~ /^%\{\s*(.+)\s*\}/) {
             $argterm = $1 . "->{'$argname'}";
         } elsif ($argterm =~ s/^%/\$/) {
             $argterm .= "{'$argname'}";
         } else {
             $argterm .= "->{'$argname'}";
         }
 
         my $has_default_prop = exists($argspec->{default});
         my $sch = $argspec->{schema};
 
         if ($sch) {
             my $has_sch_default  = ref($sch) eq 'ARRAY' &&
                 exists($sch->[1]{default}) ? 1:0;
             if ($opt_va) {
 
                 $self->push_lines("if (exists($argterm)) {");
                 $self->indent;
 
                 if ($argspec->{stream}) {
                     $self->_errif(
                         400,
                         qq["Argument '$prefix$argname' (stream) fails validation: must be coderef"],
                         "!(ref($argterm) eq 'CODE')",
                     );
                     $self->push_lines('{ ## introduce scope because we want to declare a generic variable $i');
                     $self->indent;
                     $self->push_lines(
                         'my $i = -1;',
                         "my \$origsub = $argterm;",
                         '# arg coderef wrapper for validation',
                         "$argterm = sub {",
                     );
                     $self->indent;
                     $self->push_lines(
                         '$i++;',
                         "my \$rec = \$origsub->();",
                         'return undef unless defined $rec;',
                     );
                 }
 
                 my $dn = $argname; $dn =~ s/\W+/_/g;
                 my $cd = $self->_plc->compile(
                     data_name            => $dn,
                     data_term            => $argspec->{stream} ? '$rec' : $argterm,
                     schema               => $sch,
                     schema_is_normalized => $opt_sin,
                     return_type          => 'str',
                     indent_level         => $self->get_indent_level + 1,
                     core                 => $self->{_args}{core},
                     core_or_pp           => $self->{_args}{core_or_pp},
                     pp                   => $self->{_args}{pp},
                     %{ $self->{_args}{_extra_sah_compiler_args} // {}},
                 );
                 $self->_add_modules($cd->{module_statements});
                 for (@{ $cd->{modules} }) { $self->_add_module($_) unless $cd->{module_statements}{$_} }
                 $self->_add_var($_, $cd->{vars}{$_})
                     for sort keys %{ $cd->{vars} };
                 $cd->{result} =~ s/\A\s+//;
                 $self->push_lines(
                     "my \$err_$dn;",
                     "$cd->{result};",
                 );
                 if ($argspec->{stream}) {
                     $self->push_lines(
                         'if ('."\$err_$dn".') { die "Record #$i of streaming argument '."'$prefix$argname'".' fails validation: '."\$err_$dn".'" }',
                         '$rec;',
                     );
                 } else {
                     $self->_errif(
                         400, qq["Argument '$prefix$argname' fails validation: \$err_$dn"],
                         "\$err_$dn");
                 }
                 if ($argspec->{meta}) {
                     $self->push_lines("# check subargs of $prefix$argname");
                     $self->_handle_args(
                             %args,
                             v => $argspec->{meta}{args},
                             prefix => ($prefix ? "$prefix/" : "") . "$argname/",
                             argsterm => '%{'.$argterm.'}',
                         );
                 }
                 if ($argspec->{element_meta}) {
                     $self->push_lines("# check element subargs of $prefix$argname");
                     my $indexterm = "$prefix$argname";
                     $indexterm =~ s/\W+/_/g;
                     $indexterm = '$i_' . $indexterm;
                     $self->push_lines('for my '.$indexterm.' (0..$#{ '.$argterm.' }) {');
                     $self->indent;
                     $self->_errif(
                         400, qq("Argument '$prefix$argname\[).qq($indexterm]' fails validation: must be hash"),
                         "ref($argterm\->[$indexterm]) ne 'HASH'");
                     $self->_handle_args(
                         %args,
                         v => $argspec->{element_meta}{args},
                         prefix => ($prefix ? "$prefix/" : "") . "$argname\[$indexterm]/",
                         argsterm => '%{'.$argterm.'->['.$indexterm.']}',
                     );
                     $self->unindent;
                     $self->push_lines('}');
                 }
                 $self->unindent;
                 if ($argspec->{stream}) {
                     $self->push_lines('}; ## arg coderef wrapper');
                     $self->unindent;
                     $self->push_lines('} ## close scope');
                     $self->unindent;
                 }
                 if ($has_default_prop) {
                     $self->push_lines(
                         '} else {',
                         "    $argterm //= ".__squote($argspec->{default}).";");
                 } elsif ($has_sch_default) {
                     $self->push_lines(
                         '} else {',
                         "    $argterm //= ".__squote($sch->[1]{default}).";");
                 }
                 $self->push_lines("} ## if exists arg $prefix$argname");
             } 
 
         } elsif ($has_default_prop) {
             $self->push_lines("$argterm = ".__squote($argspec->{default}).
                                   " if !exists($argterm);");
         }
         if ($argspec->{req} && $opt_va) {
             $self->_errif(
                 400, qq["Missing required argument: $argname"],
                 "!exists($argterm)");
         }
     } 
 }
 
 sub handlemeta_args { {v=>2, prio=>10} }
 sub handle_args {
     my ($self, %args) = @_;
     $self->_handle_args(%args);
 }
 
 sub handlemeta_args_rels { {v=>2, prio=>11} }
 sub handle_args_rels {
     my ($self, %args) = @_;
 
     my $v = $args{v} // $self->{_meta}{args_rels};
     return unless $v;
 
     my $argsterm = $args{argsterm} // '%args';
 
     $self->select_section('before_call_arg_validation');
     $self->push_lines('', '# check args_rels');
 
     my $dn = "args_rels";
     my $hc = $self->_sah->get_compiler("human");
     my $cd_h = $hc->init_cd;
     $cd_h->{args}{lang} //= $cd_h->{default_lang};
 
     my $cd = $self->_plc->compile(
         data_name            => $dn,
         data_term            => "\\$argsterm",
         schema               => ['hash', $v],
         return_type          => 'str',
         indent_level         => $self->get_indent_level + 1,
         human_hash_values    => {
             field  => $hc->_xlt($cd_h, "argument"),
             fields => $hc->_xlt($cd_h, "arguments"),
         },
         core                 => $self->{_args}{core},
         core_or_pp           => $self->{_args}{core_or_pp},
         pp                   => $self->{_args}{pp},
     );
     $self->_add_modules($cd->{module_statements});
     for (@{ $cd->{modules} }) { $self->_add_module($_) unless $cd->{module_statements}{$_} }
     $self->_add_var($_, $cd->{vars}{$_}) for sort keys %{ $cd->{vars} };
     $cd->{result} =~ s/\A\s+//;
     $self->push_lines(
         "my \$err_$dn;",
         "$cd->{result};",
     );
     $self->_errif(
         400, qq["\$err_$dn"],
         "\$err_$dn");
 }
 
 sub handlemeta_result { {v=>2, prio=>50} }
 sub handle_result {
     require Data::Sah;
 
     my ($self, %args) = @_;
 
     my $meta = $self->{_meta};
     my $v = $meta->{result};
     return unless $v;
 
     my $opt_sin = $self->{_args}{_schema_is_normalized};
     my $opt_vr  = $self->{_args}{validate_result};
 
     my %schemas_by_status; 
 
     my %handler_args;
     my %handler_metas;
     for my $k0 (keys %$v) {
         my $k = $k0;
         $k =~ s/\..+//;
         next if $k =~ /\A_/;
 
         next if $k =~ /\A(
                            summary|description|tags|default_lang|
                            schema|statuses|stream|
                            x
                        )\z/x;
         require "Perinci/Sub/Property/result/$k.pm";
         my $meth = "handlemeta_result__$k";
         unless ($self->can($meth)) {
             die "No handler for property result/$k0 ($meth)";
         }
         my $hm = $self->$meth;
         $hm->{v} //= 1;
         next unless defined $hm->{prio};
         die "Please update property handler result/$k which is still at v=$hm->{v} ".
             "(needs v=$protocol_version)"
                 unless $hm->{v} == $protocol_version;
         my $ha = {
             prio=>$hm->{prio}, value=>$v->{$k0}, property=>$k0,
             meth=>"handle_result__$k",
         };
         $handler_args{$k} = $ha;
         $handler_metas{$k} = $hm;
     }
 
     for my $k (sort {$handler_args{$a}{prio} <=> $handler_args{$b}{prio}}
                    keys %handler_args) {
         my $ha = $handler_args{$k};
         my $meth = $ha->{meth};
         local $self->{_cur_handler}      = $meth;
         local $self->{_cur_handler_meta} = $handler_metas{$k};
         local $self->{_cur_handler_args} = $ha;
         $self->$meth(args=>\%args, meta=>$meta, %$ha);
     }
 
     my @modules;
     if ($v->{schema} && $opt_vr) {
         $schemas_by_status{200} = $v->{schema};
     }
     if ($v->{statuses} && $opt_vr) {
         for my $s (keys %{$v->{statuses}}) {
             my $sv = $v->{statuses}{$s};
             if ($sv->{schema}) {
                 $schemas_by_status{$s} = $sv->{schema};
             }
         }
     }
 
     my $sub_name = $self->{_args}{sub_name};
 
     if ($opt_vr) {
         $self->select_section('after_call_res_validation');
         $self->push_lines(
             'my $_w_res2 = $_w_res->[2];',
             'my $_w_res_is_stream = $_w_res->[3]{stream} // ' . ($v->{stream} ? 1:0) . ';',
         );
         $self->_errif(
             500,
             q["Stream result must be coderef"],
             '$_w_res_is_stream && ref($_w_res2) ne "CODE"',
         );
         for my $s (sort keys %schemas_by_status) {
             my $sch = $schemas_by_status{$s};
             $self->push_lines("if (\$_w_res->[0] == $s) {");
             $self->indent;
             $self->push_lines('if (!$_w_res_is_stream) {');
             $self->indent;
 
             my $cd = $self->_plc->compile(
                 data_name            => '_w_res2',
                 err_term             => '$_w_err2_res',
                 schema               => $sch,
                 schema_is_normalized => $opt_sin,
                 return_type          => 'str',
                 indent_level         => $self->get_indent_level + 1,
                 core                 => $self->{_args}{core},
                 core_or_pp           => $self->{_args}{core_or_pp},
                 pp                   => $self->{_args}{pp},
                 %{ $self->{_args}{_extra_sah_compiler_args} // {}},
             );
             $self->_add_modules($cd->{module_statements});
             for (@{ $cd->{modules} }) { $self->_add_module($_) unless $cd->{module_statements}{$_} }
             $self->_add_var($_, $cd->{vars}{$_})
                 for sort keys %{ $cd->{vars} };
             $self->push_lines("my \$_w_err2_res;");
             $cd->{result} =~ s/\A\s+//;
             $self->push_lines("$cd->{result};");
             $self->_errif(
                 500,
                 qq["BUG: Result from sub $sub_name fails validation: ].
                     qq[\$_w_err2_res"],
                 "\$_w_err2_res");
             $self->unindent;
             $self->push_lines("} else {"); 
             $self->indent;
             $self->push_lines(
                 'my $i = -1;',
                 '# wrap result coderef for validation',
                 '$_w_res->[2] = sub {',
             );
             $self->indent;
             $self->push_lines(
                 '$i++;',
                 'my $rec = $_w_res2->();',
                 'return undef unless defined $rec;',
             );
             $cd = $self->_plc->compile(
                 data_name            => 'rec',
                 err_term             => '$rec_err',
                 schema               => $sch,
                 schema_is_normalized => $opt_sin,
                 return_type          => 'str',
                 indent_level         => $self->get_indent_level + 1,
                 core                 => $self->{_args}{core},
                 core_or_pp           => $self->{_args}{core_or_pp},
                 pp                   => $self->{_args}{pp},
                 %{ $self->{_args}{_extra_sah_compiler_args} // {}},
             );
             $self->push_lines('my $rec_err;');
             $cd->{result} =~ s/\A\s+//;
             $self->push_lines("$cd->{result};");
             $self->push_lines('if ($rec_err) { die "BUG: Result stream record #$i fail validation: $rec_err" }');
             $self->push_lines('$rec;');
             $self->unindent;
             $self->push_lines('}; ## result coderef wrapper');
             $self->unindent;
             $self->push_lines("} ## if stream");
             $self->unindent;
             $self->push_lines("} ## if status=$s");
         } 
     }
 }
 
 sub handlemeta_result_naked { {v=>2, prio=>99, convert=>1} }
 sub handle_result_naked {
     my ($self, %args) = @_;
 
     my $old = $args{value};
     my $v   = $args{new} // $old;
 
     return if !!$v == !!$old;
 
     $self->select_section('AFTER_CALL_ADD_OR_STRIP_RESULT_ENVELOPE');
     if ($v) {
         $self->push_lines(
             '', '# strip result envelope',
             '$_w_res = $_w_res->[2];',
         );
     } else {
         $self->push_lines(
             '', '# add result envelope',
             '$_w_res = [200, "OK", $_w_res];',
         );
     }
 }
 
 sub handlemeta_deps { {v=>2, prio=>0.5} }
 sub handle_deps {
     my ($self, %args) = @_;
     my $value = $args{value};
     my $meta  = $self->{_meta};
     my $v     = $self->{_args}{meta_name};
     $self->select_section('before_call_after_arg_validation');
     $self->push_lines('', '# check dependencies');
     $self->_add_module("Perinci::Sub::DepChecker");
     $self->push_lines('my $_w_deps_res = Perinci::Sub::DepChecker::check_deps('.
                           $v.'->{deps});');
     $self->_errif(412, '"Deps failed: $_w_deps_res"', '$_w_deps_res');
 
     if ($value->{tmp_dir}) {
         $self->_errif(412, '"Dep failed: please specify -tmp_dir"',
                       '!$args{-tmp_dir}');
     }
     if ($value->{trash_dir}) {
         $self->_errif(412, '"Dep failed: please specify -trash_dir"',
                       '!$args{-trash_dir}');
     }
     if ($value->{undo_trash_dir}) {
         $self->_errif(412, '"Dep failed: please specify -undo_trash_dir"',
                       '!($args{-undo_trash_dir} || $args{-tx_manager} || '.
                           '$args{-undo_action} && $args{-undo_action}=~/\A(?:undo|redo)\z/)');
     }
 }
 
 sub handlemeta_x { {} }
 sub handlemeta_entity_v { {} }
 sub handlemeta_entity_date { {} }
 
 sub _reset_work_data {
     my ($self, %args) = @_;
 
 
     $self->{_cur_section}      = undef;
     $self->{_cur_handler}      = undef;
     $self->{_cur_handler_args} = undef;
     $self->{_cur_handler_meta} = undef;
     $self->{_levels}           = {};
     $self->{_codes}            = {};
     $self->{_modules}          = []; 
     $self->{$_} = $args{$_} for keys %args;
 }
 
 sub wrap {
     require Scalar::Util;
 
     my ($self, %args) = @_;
 
     my $wrap_log_prop = "x.perinci.sub.wrapper.logs";
 
     my $sub      = $args{sub};
     my $sub_name = $args{sub_name};
     $sub || $sub_name or return [400, "Please specify sub or sub_name"];
     $args{meta} or return [400, "Please specify meta"];
     my $meta_name = $args{meta_name};
     my $meta     = clone($args{meta});
     my $wrap_logs = $meta->{$wrap_log_prop} // [];
 
     $args{_compiled_package}           //= 'Perinci::Sub::Wrapped';
     my $comppkg  = $args{_compiled_package};
     $args{_schema_is_normalized}       //=
         $wrap_logs->[-1] && $wrap_logs->[-1]{normalize_schema} ? 1 : 0;
     $args{_embed}                      //= 0;
     $args{_extra_sah_compiler_args}    //= undef;
 
     $args{indent}                      //= " " x 4;
     $args{convert}                     //= {};
     $args{compile}                     //= 1;
     $args{log}                         //= 1;
     $args{validate_args}               //= 0
         if $meta->{'x.perinci.sub.wrapper.disable_validate_args'};
     $args{validate_args}               //= 0
         if (grep {$_->{validate_args}} @$wrap_logs);
     $args{validate_args}               //= 1;
     $args{validate_result}             //= 0
         if $meta->{'x.perinci.sub.wrapper.disable_validate_result'};
     $args{validate_result}             //= 0
         if (grep {$_->{validate_result}} @$wrap_logs);
     $args{validate_result}             //= 1;
     $args{core}                        //= $ENV{PERINCI_WRAPPER_CORE};
     $args{core_or_pp}                  //= $ENV{PERINCI_WRAPPER_CORE_OR_PP};
     $args{pp}                          //= $ENV{PERINCI_WRAPPER_PP};
 
     my $sub_ref_name;
     if (!$sub_name || $sub) {
         my $n = $comppkg . "::sub".Scalar::Util::refaddr($sub);
         no strict 'refs'; no warnings; ${$n} = $sub;
         use experimental 'smartmatch';
         if (!$sub_name) {
             $args{sub_name} = $sub_name = '$' . $n;
         }
         $sub_ref_name = '$' . $n;
     }
     if (!$meta_name) {
         my $n = $comppkg . "::meta".Scalar::Util::refaddr($meta);
         no strict 'refs'; no warnings; ${$n} = $meta;
         use experimental 'smartmatch';
         $args{meta_name} = $meta_name = '$' . $n;
     }
 
     my $opt_cvt = { %{ $args{convert} } };
     my $opt_sin = $args{_schema_is_normalized};
 
     $meta = normalize_function_metadata($meta)
         unless $opt_sin;
 
     $self->_reset_work_data(_args=>\%args, _meta=>$meta);
 
     for (keys %$opt_cvt) {
         $meta->{$_} = undef unless exists $meta->{$_};
     }
 
     {
         my @wrap_log = @{ $meta->{$wrap_log_prop} // [] };
         push @wrap_log, {
             validate_args     => $args{validate_args},
             validate_result   => $args{validate_result},
             normalize_schema  => !$opt_sin,
         };
         if ($args{log}) {
             $meta->{$wrap_log_prop} = \@wrap_log;
         }
     }
 
 
     $self->select_section('OPEN_SUB');
     $self->push_lines(
         "package $comppkg;", 'sub {');
     $self->indent;
 
     $meta->{args_as} //= "hash";
 
     if ($meta->{args_as} =~ /hash/) {
         $self->select_section('before_call_after_arg_validation');
     }
 
     my %props = map {$_=>1} keys %$meta;
     $props{$_} = 1 for keys %$opt_cvt;
 
     my %handler_args;
     my %handler_metas;
     for my $k0 (keys %props) {
         my $k = $k0;
         $k =~ s/\..+//;
         next if $k =~ /\A_/;
         next if $handler_args{$k};
         return [500, "Invalid property name $k"] unless $k =~ /\A\w+\z/;
         my $meth = "handlemeta_$k";
         unless ($self->can($meth)) {
             require "Perinci/Sub/Property/$k.pm";
             unless ($self->can($meth)) {
                 return [500, "No handler for property $k0 ($meth)"];
             }
         }
         my $hm = $self->$meth;
         $hm->{v} //= 1;
         next unless defined $hm->{prio};
         die "Please update property handler $k which is still at v=$hm->{v} ".
             "(needs v=$protocol_version)"
                 unless $hm->{v} == $protocol_version;
         my $ha = {
             prio=>$hm->{prio}, value=>$meta->{$k0}, property=>$k0,
             meth=>"handle_$k",
         };
         if (exists $opt_cvt->{$k0}) {
             return [501, "Property '$k0' does not support conversion"]
                 unless $hm->{convert};
             $ha->{new}   = $opt_cvt->{$k0};
             $meta->{$k0} = $opt_cvt->{$k0};
         }
         $handler_args{$k}  = $ha;
         $handler_metas{$k} = $hm;
     }
 
     for my $k (sort {$handler_args{$a}{prio} <=> $handler_args{$b}{prio}}
                    keys %handler_args) {
         my $ha = $handler_args{$k};
         my $meth = $ha->{meth};
         local $self->{_cur_handler}      = $meth;
         local $self->{_cur_handler_meta} = $handler_metas{$k};
         local $self->{_cur_handler_args} = $ha;
         $self->$meth(args=>\%args, meta=>$meta, %$ha);
     }
 
     my $needs_store_res = $self->_needs_store_res;
     if ($needs_store_res) {
         $self->_add_var('_w_res');
     }
 
     $self->select_section('CALL');
     my $sn = $sub_ref_name // $sub_name;
     $self->push_lines(
         ($needs_store_res ? '$_w_res = ' : "") .
         $sn. ($sn =~ /^\$/ ? "->" : "").
             "(".$self->{_args_token}.");");
     if ($args{validate_result}) {
         $self->select_section('after_call_before_res_validation');
         unless ($meta->{result_naked}) {
             $self->push_lines(
                 '',
                 '# check that sub produces enveloped result',
                 'unless (ref($_w_res) eq "ARRAY" && $_w_res->[0]) {',
             );
             $self->indent;
             if ($log->is_trace) {
                 $self->_add_module('Data::Dumper');
                 $self->push_lines(
                     'local $Data::Dumper::Purity   = 1;',
                     'local $Data::Dumper::Terse    = 1;',
                     'local $Data::Dumper::Indent   = 0;',
                 );
                 $self->_err(500,
                             qq['BUG: Sub $sub_name does not produce envelope: '.].
                                 qq[Data::Dumper::Dumper(\$_w_res)]);
             } else {
                 $self->_err(500,
                             qq['BUG: Sub $sub_name does not produce envelope']);
             }
             $self->unindent;
             $self->push_lines('}');
         }
     }
 
     my $use_eval = $self->_needs_eval;
     if ($use_eval) {
         $self->select_section('CLOSE_EVAL');
         $self->push_lines('return $_w_res;');
         $self->unindent;
         $self->_add_var('_w_eval_err');
         $self->push_lines(
             '};',
             '$_w_eval_err = $@;');
 
         $self->select_section('after_eval');
         $self->push_lines('warn $_w_eval_err if $_w_eval_err;');
         $self->_errif(500, '"Function died: $_w_eval_err"', '$_w_eval_err');
 
         $self->select_section('OPEN_EVAL');
         $self->push_lines('eval {');
         $self->indent;
     }
 
     $self->select_section('BEFORE_CLOSE_SUB');
     $self->push_lines('return $_w_res;') if $needs_store_res;
     $self->select_section('CLOSE_SUB');
     $self->unindent;
     $self->push_lines('}'); 
 
     my $result = {
         sub_name     => $sub_name,
         sub_ref_name => $sub_ref_name,
         meta         => $meta,
         meta_name    => $meta_name,
         use_eval     => $use_eval,
     };
     if ($args{embed}) {
         $result->{source} = $self->_format_embed_wrapper_code;
     } else {
         my $source = $self->_format_dyn_wrapper_code;
         if ($Log_Wrapper_Code && $log->is_trace) {
             require String::LineNumber;
             $log->tracef("wrapper code:\n%s",
                          $ENV{LINENUM} // 1 ?
                              String::LineNumber::linenum($source) :
                                    $source);
         }
         $result->{source} = $source;
         if ($args{compile}) {
             my $wrapped = eval $source;
             die "BUG: Wrapper code can't be compiled: $@" if $@ || !$wrapped;
             $result->{sub}  = $wrapped;
         }
     }
 
     [200, "OK", $result];
 }
 
 $SPEC{wrap_sub} = {
     v => 1.1,
     summary => 'Wrap subroutine to do various things, '.
         'like enforcing Rinci properties',
     result => {
         summary => 'The wrapped subroutine along with its new metadata',
         description => <<'_',
 
 Aside from wrapping the subroutine, the wrapper will also create a new metadata
 for the subroutine. The new metadata is a clone of the original, with some
 properties changed, e.g. schema in `args` and `result` normalized, some values
 changed according to the `convert` argument, some defaults set, etc.
 
 The new metadata will also contain (or append) the wrapping log located in the
 `x.perinci.sub.wrapper.logs` attribute. The wrapping log marks that the wrapper
 has added some functionality (like validating arguments or result) so that
 future nested wrapper can choose to avoid duplicating the same functionality.
 
 _
         schema=>['hash*'=>{keys=>{
             sub=>'code*',
             source=>['any*' => of => ['str*', ['hash*' => each_value=>'str*']]],
             meta=>'hash*',
         }}],
     },
     args => {
         sub => {
             schema => 'str*',
             summary => 'The code to be wrapped',
             description => <<'_',
 
 At least one of `sub` or `sub_name` must be specified.
 
 _
         },
         sub_name => {
             schema => 'str*',
             summary => 'The name of the subroutine, '.
                 'e.g. func or Foo::func (qualified)',
             description => <<'_',
 
 At least one of `sub` or `sub_name` must be specified.
 
 _
         },
         meta => {
             schema => 'hash*',
             summary => 'The function metadata',
             req => 1,
         },
         meta_name => {
             schema => 'str*',
             summary => 'Where to find the metadata, e.g. "$SPEC{foo}"',
             description => <<'_',
 
 Some wrapper code (e.g. handler for `dep` property) needs to refer to the
 function metadata. If not provided, the wrapper will store the function metadata
 in a unique variable (e.g. `$Perinci::Sub::Wrapped::meta34127816`).
 
 _
         },
         convert => {
             schema => 'hash*',
             summary => 'Properties to convert to new value',
             description => <<'_',
 
 Not all properties can be converted, but these are a partial list of those that
 can: v (usually do not need to be specified when converting from 1.0 to 1.1,
 will be done automatically), args_as, result_naked, default_lang.
 
 _
         },
         compile => {
             schema => ['bool' => {default=>1}],
             summary => 'Whether to compile the generated wrapper',
             description => <<'_',
 
 Can be set to 0 to not actually wrap but just return the generated wrapper
 source code.
 
 _
         },
         compile => {
             schema => ['bool' => {default=>1}],
             summary => 'Whether to compile the generated wrapper',
             description => <<'_',
 
 Can be set to 0 to not actually wrap but just return the generated wrapper
 source code.
 
 _
         },
         debug => {
             schema => [bool => {default=>0}],
             summary => 'Generate code with debugging',
             description => <<'_',
 
 If turned on, will produce various debugging in the generated code. Currently
 what this does:
 
 * add more comments (e.g. for each property handler)
 
 _
         },
         validate_args => {
             schema => ['bool'],
             summary => 'Whether wrapper should validate arguments',
             description => <<'_',
 
 If set to true, will validate arguments. Validation error will cause status 400
 to be returned. The default is to enable this unless previous wrapper(s) have
 already done this.
 
 _
         },
         validate_result => {
             schema => ['bool'],
             summary => 'Whether wrapper should validate arguments',
             description => <<'_',
 
 If set to true, will validate sub's result. Validation error will cause wrapper
 to return status 500 instead of sub's result. The default is to enable this
 unless previous wrapper(s) have already done this.
 
 _
         },
         core => {
             summary => 'If set to true, will avoid the use of non-core modules',
             schema => 'bool',
         },
         core_or_pp => {
             summary => 'If set to true, will avoid the use of non-core XS modules',
             schema => 'bool',
             description => <<'_',
 
 In other words, will stick to core or pure-perl modules only.
 
 _
         },
         pp => {
             summary => 'If set to true, will avoid the use of XS modules',
             schema => 'bool',
         },
     },
 };
 sub wrap_sub {
     __PACKAGE__->new->wrap(@_);
 }
 
 1;
 
 __END__
 
### Proc/PID/File.pm ###
 
 package Proc::PID::File;
 
 
 require Exporter;
 @ISA = qw(Exporter);
 
 use strict;
 use vars qw($VERSION $RPM_Requires);
 use Fcntl qw(:DEFAULT :flock);
 
 $VERSION = "1.27";
 $RPM_Requires = "procps";
 
 my $RUNDIR = "/var/run";
 my ($ME) = $0 =~ m|([^/]+)$|;
 my $self;
 
 
 
 sub running {
     $self = shift->new(@_);
 
 	local *FH;
 	my $pid = $self->read(*FH);
 
 	if ($pid && $pid != $$ && kill(0, $pid)) {
         $self->debug("running: $pid");
 	    close FH;
         return $self->verify($pid) ? $pid : 0;
         }
 
 	$self->write(*FH);
 	return 0;
     }
 
 
 
 sub new {
 	my $class = shift;
 	my $self = bless({}, $class);
 	%$self = &args;
 	$self->file();	
 	$self->{debug} ||= "";
 	return $self;
 	}
 
 
 sub file {
 	my $self = shift;
 	%$self = (%$self, &args);
 	$self->{dir} ||= $RUNDIR;
 	$self->{name} ||= $ME;
 	$self->{path} = sprintf("%s/%s.pid", $self->{dir}, $self->{name});
 	}
 
 
 sub alive {
 	my $self = shift;
 
 	my %args = &args;
 	$self->{verify} = $args{verify} if $args{verify};
 
 	my $pid = $self->read() || "";
 	$self->debug("alive(): $pid");
 
 	if ($pid && $pid != $$ && kill(0, $pid)) {
         return $self->verify($pid) ? $pid : 0;
         }
 
 	return 0;
 	}
 
 
 sub touch {
 	shift->write();
 	}
 
 
 sub release {
 	my $self = shift;
 	$self->debug("release()");
 	unlink($self->{path}) || warn $!;
 	}
 
 
 sub locktime {
     my $self = shift;
     return (stat($self->{path}))[10];
 	}
 
 
 sub verify {
     my ($self, $pid) = @_;
     return 1 unless $self->{verify};
 
 	my $ret = 0;
     $self->debug("verify(): OS = $^O");
     if ($^O =~ /linux|freebsd|cygwin/i) {
         my $me = $self->{verify};
 		if (!$me || $me eq "1") {
 			$me = $ME;
 			if ($^O eq "cygwin") {
 				$^X =~ m|([^/]+)$|;
 				($me = $1) =~ s/\.exe$//;
 				}
 			}
 		my $cols = delete($ENV{'COLUMNS'}); 
         my @ps = split m|$/|, qx/ps -fp $pid/
             || die "ps utility not available: $!";
         s/^\s+// for @ps;   
 
 		$ENV{'COLUMNS'} = $cols if defined($cols);
         no warnings;    
         my $n = split(/\s+/, $ps[0]);
         @ps = split /\s+/, $ps[1], $n;
         $ret = $ps[$n - 1] =~ /\Q$me\E/;;
         }
 
 	$self->debug(" - ret: [$ret]");
 	$ret;
     }
 
 
 sub read {
 	my ($self, $fh) = @_;
 
 	sysopen $fh, $self->{path}, O_RDWR|O_CREAT
 		|| die qq/Cannot open pid file "$self->{path}": $!\n/;
 	flock($fh, LOCK_EX | LOCK_NB)
         || die qq/pid "$self->{path}" already locked: $!\n/;
 	my ($pid) = <$fh> =~ /^(\d+)/;
 	close $fh if @_ == 1;
 
 	$self->debug("read(\"$self->{path}\") = " . ($pid || ""));
 	return $pid;
 	}
 
 
 sub write {
 	my ($self, $fh) = @_;
 
 	$self->debug("write($$)");
 	if (@_ == 1) {
 		sysopen $fh, $self->{path}, O_RDWR|O_CREAT
 			|| die qq/Cannot open pid file "$self->{path}": $!\n/;
 		flock($fh, LOCK_EX | LOCK_NB)
         	|| die qq/pid "$self->{path}" already locked: $!\n/;
 		}
 	sysseek  $fh, 0, 0;
 	truncate $fh, 0;
 	syswrite $fh, "$$\n", length("$$\n");
 	close $fh || die qq/Cannot write pid file "$self->{path}": $!\n/;
 	}
 
 sub args {
 	!defined($_[0]) ? () : ref($_[0]) ? %{$_[0]} : @_;
 	}
 
 sub debug {
 	my $self = shift;
 	my $msg = shift || $_;
 
 	$msg = "> Proc::PID::File - $msg"
 		if $self->{debug} =~ /M/;	
 	print $msg
 		if $self->{debug};
 	}
 
 sub DESTROY {
 	my $self = shift;
 
     if (exists($INC{'threads.pm'})) {
         return if threads->tid() != 0;
     	}
     
 	my $pid = $self->read();
 	$self->release()
         if $self->{path} && $pid && $pid == $$;
 	}
 
 1;
 
 __END__
 
 # -- documentation -----------------------------------------------------------
 
### Progress/Any.pm ###
 package Progress::Any;
 
 our $DATE = '2015-01-27'; 
 our $VERSION = '0.20'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Time::Duration qw();
 use Time::HiRes qw(time);
 
 sub import {
     my ($self, @args) = @_;
     my $caller = caller();
     for (@args) {
         if ($_ eq '$progress') {
             my $progress = $self->get_indicator(task => '');
             {
                 no strict 'refs';
                 my $v = "$caller\::progress";
                 *$v = \$progress;
             }
         } else {
             die "Unknown import argument: $_";
         }
     }
 }
 
 our %indicators;  
 
 our %outputs;     
 
 our %output_data; 
 
 
 sub _init_indicator {
     my ($class, $task) = @_;
 
 
     return $indicators{$task} if $indicators{$task};
 
     my $progress = bless({
         task        => $task,
         title       => $task,
         target      => 0,
         pos         => 0,
         state       => 'stopped',
 
         _remaining          => undef,
         _set_remaining_time => undef,
         _elapsed            => 0,
         _start_time         => 0,
     }, $class);
     $indicators{$task} = $progress;
 
     if ($task =~ s/\.?\w+\z//) {
         $class->_init_indicator($task);
     }
 
     $progress;
 }
 
 sub get_indicator {
     my ($class, %args) = @_;
 
     my %oargs = %args;
 
     my $task   = delete($args{task});
     if (!defined($task)) {
         my @caller = caller(0);
         $task = $caller[0] eq '(eval)' ? 'main' : $caller[0];
         $task =~ s/::/./g;
         $task =~ s/[^.\w]+/_/g;
     }
     die "Invalid task syntax '$task', please only use dotted words"
         unless $task =~ /\A(?:\w+(\.\w+)*)?\z/;
 
     my %uargs;
 
     my $p = $class->_init_indicator($task);
     for my $an (qw/title target pos remaining state/) {
         if (exists $args{$an}) {
             $uargs{$an} = delete($args{$an});
         }
     }
     die "Unknown argument(s) to get_indicator(): ".join(", ", keys(%args))
         if keys(%args);
     $p->_update(%uargs) if keys %uargs;
 
     $p;
 }
 
 my %attrs = (
     title     => {is => 'rw'},
     target    => {is => 'rw'},
     pos       => {is => 'rw'},
     state     => {is => 'rw'},
 );
 
 for my $an (keys %attrs) {
     next if $attrs{$an}{manual};
     my $code;
     if ($attrs{$an}{is} eq 'rw') {
         $code = sub {
             my $self = shift;
             if (@_) {
                 $self->_update($an => shift);
             }
             $self->{$an};
         };
     } else {
         $code = sub {
             my $self = shift;
             die "Can't set value, $an is an ro attribute" if @_;
             $self->{$an};
         };
     }
     no strict 'refs';
     *{$an} = $code;
 }
 
 sub elapsed {
     my $self = shift;
 
     if ($self->{state} eq 'started') {
         return $self->{_elapsed} + (time()-$self->{_start_time});
     } else {
         return $self->{_elapsed};
     }
 }
 
 sub total_pos {
     my $self = shift;
 
     my $t = $self->{task};
 
     my $res = $self->{pos};
     for (keys %indicators) {
         if ($t eq '') {
             next if $_ eq '';
         } else {
             next unless index($_, "$t.") == 0;
         }
         $res += $indicators{$_}{pos};
     }
     $res;
 }
 
 sub total_target {
     my $self = shift;
 
     my $t = $self->{task};
 
     my $res = $self->{target};
     return undef unless defined($res);
 
     for (keys %indicators) {
         if ($t eq '') {
             next if $_ eq '';
         } else {
             next unless index($_, "$t.") == 0;
         }
         return undef unless defined $indicators{$_}{target};
         $res += $indicators{$_}{target};
     }
     $res;
 }
 
 sub percent_complete {
     my $self = shift;
 
     my $total_pos    = $self->total_pos;
     my $total_target = $self->total_target;
 
     return undef unless defined($total_target);
     if ($total_target == 0) {
         if ($self->{state} eq 'finished') {
             return 100;
         } else {
             return 0;
         }
     } else {
         return $total_pos / $total_target * 100;
     }
 }
 
 sub remaining {
     my $self = shift;
 
     if (defined $self->{_remaining}) {
         if ($self->{state} eq 'started') {
             my $r = $self->{_remaining}-(time()-$self->{_set_remaining_time});
             return $r > 0 ? $r : 0;
         } else {
             return $self->{_remaining};
         }
     } else {
         if (defined $self->{target}) {
             if ($self->{pos} == 0) {
                 return 0;
             } else {
                 return ($self->{target} - $self->{pos})/$self->{pos} *
                     $self->elapsed;
             }
         } else {
             return undef;
         }
     }
 }
 
 sub total_remaining {
     my $self = shift;
 
     my $t = $self->{task};
 
     my $res = $self->remaining;
     return undef unless defined $res;
 
     for (keys %indicators) {
         if ($t eq '') {
             next if $_ eq '';
         } else {
             next unless index($_, "$t.") == 0;
         }
         my $res2 = $indicators{$_}->remaining;
         return undef unless defined $res2;
         $res += $res2;
     }
     $res;
 }
 
 sub _update {
     my ($self, %args) = @_;
 
 
     my $now = time();
 
     my $task = $self->{task};
 
   SET_TITLE:
     {
         last unless exists $args{title};
         my $val = $args{title};
         die "Invalid value for title, must be defined"
             unless defined($val);
         $self->{title} = $val;
     }
 
   SET_TARGET:
     {
         last unless exists $args{target};
         my $val = $args{target};
         die "Invalid value for target, must be a positive number or undef"
             unless !defined($val) || $val >= 0;
         if (defined($val) && $self->{pos} > $val) {
             $self->{pos} = $val;
         }
         $self->{target} = $val;
         undef $self->{_remaining};
     }
 
   SET_POS:
     {
         last unless exists $args{pos};
         my $val = $args{pos};
         die "Invalid value for pos, must be a positive number"
             unless defined($val) && $val >= 0;
         if (defined($self->{target}) && $val > $self->{target}) {
             $val = $self->{target};
         }
         $self->{pos} = $val;
         undef $self->{_remaining};
     }
 
   SET_REMAINING:
     {
         last unless exists $args{remaining};
         my $val = $args{remaining};
         die "Invalid value for remaining, must be a positive number"
             unless defined($val) && $val >= 0;
         $self->{_remaining} = $val;
         $self->{_set_remaining_time} = $now;
     }
 
   SET_STATE:
     {
         last unless exists $args{state};
         my $old = $self->{state};
         my $val = $args{state} // 'started';
         die "Invalid value for state, must be stopped/started/finished"
             unless $val =~ /\A(?:stopped|started|finished)\z/;
         last if $old eq $val;
         if ($val eq 'started') {
             $self->{_start_time} = $now;
 
             my @parents;
             {
                 my $t = $task;
                 while (1) {
                     last unless $t =~ s/\.\w+\z//;
                     push @parents, $t;
                 }
                 push @parents, '';
             }
             for my $t (@parents) {
                 my $p = $indicators{$t};
                 if ($p->{state} ne 'started') {
                     $p->{state}       = 'started';
                     $p->{_start_time} = $now;
                 }
             }
         } else {
             $self->{_elapsed} += $now - $self->{_start_time};
             if ($val eq 'finished') {
                 die "BUG: Can't finish task '$task', pos is still < target"
                     if defined($self->{target}) &&
                         $self->{pos} < $self->{target};
                 $self->{_remaining} = 0;
                 $self->{_set_remaining_time} = $now;
             }
         }
         $self->{state} = $val;
     }
 
   DONE:
     return;
 }
 
 sub _should_update_output {
     my ($self, $output, $now) = @_;
 
     my $key = "$output";
     $output_data{$key} //= {};
     my $odata = $output_data{$key};
     if (!defined($odata->{mtime})) {
         return 1;
     } elsif ($self->{state} eq 'finished') {
         return 1;
     } elsif ($odata->{force_update}) {
         delete $odata->{force_update};
         return 1;
     } else {
         if (!defined($odata->{freq})) {
             $odata->{freq} = -0.5;
         }
         if ($odata->{freq} < 0) {
             return 1 if $now >= $odata->{mtime} - $odata->{freq};
         } else {
             return 1 if abs($self->{pos} - $odata->{pos}) >= $odata->{freq};
         }
         return 0;
     }
 }
 
 sub update {
     my ($self, %args) = @_;
 
     my $pos   = delete($args{pos}) // $self->{pos} + 1;
     my $state = delete($args{state}) // 'started';
     $self->_update(pos => $pos, state => $state);
 
     my $message  = delete($args{message});
     my $level    = delete($args{level});
     die "Unknown argument(s) to update(): ".join(", ", keys(%args))
         if keys(%args);
 
     my $now = time();
 
     {
         my $task = $self->{task};
         while (1) {
             if ($outputs{$task}) {
                 for my $output (@{ $outputs{$task} }) {
                     next unless $self->_should_update_output($output, $now);
                     if (ref($message) eq 'CODE') {
                         $message = $message->();
                     }
                     $output->update(
                         indicator => $indicators{$task},
                         message   => $message,
                         level     => $level,
                         time      => $now,
                     );
                     my $key = "$output";
                     $output_data{$key}{mtime} = $now;
                     $output_data{$key}{pos}   = $pos;
                 }
             }
             last unless $task =~ s/\.?\w+\z//;
         }
     }
 }
 
 sub start {
     my $self = shift;
     $self->_update(state => 'started');
 }
 
 sub stop {
     my $self = shift;
     $self->_update(state => 'stopped');
 }
 
 sub finish {
     my ($self, %args) = @_;
     $self->update(pos=>$self->{target}, state=>'finished', %args);
 }
 
 sub fill_template {
     my ($self, $template, %args) = @_;
 
 
     state $re = qr{( # all=1
                        %
                        ( #width=2
                            -?\d+ )?
                        ( #dot=3
                            \.?)
                        ( #prec=4
                            \d+)?
                        ( #conv=5
                            [emnPpRrTt%])
                    )}x;
 
     state $sub = sub {
         my %args = @_;
 
         my ($all, $width, $dot, $prec, $conv) = ($1, $2, $3, $4, $5);
 
         my $p = $args{indicator};
 
         my ($fmt, $sconv, $data);
         if ($conv eq 'n') {
             $data = $p->{task};
         } elsif ($conv eq 't') {
             $data = $p->{title};
         } elsif ($conv eq '%') {
             $data = '%';
         } elsif ($conv eq 'm') {
             $data = $args{message} // '';
         } elsif ($conv eq 'p') {
             my $val = $p->percent_complete;
             $width //= 3;
             if (defined $val) {
                 $data = $val;
                 $prec //= 0;
                 $sconv = "f";
             } else {
                 $data = '?';
             }
         } elsif ($conv eq 'P') {
             $data = $p->total_pos;
             $prec //= 0;
             $sconv = "f";
         } elsif ($conv eq 'T') {
             my $val = $p->total_target;
             if (defined $val) {
                 $data = $val;
                 $prec //= 0;
                 $sconv = "f";
             } else {
                 $data = '?';
             }
         } elsif ($conv eq 'e') {
             my $val = $p->elapsed;
             $val = 1 if $val < 1; 
             $data = Time::Duration::concise(Time::Duration::duration($val));
             $width //= -8;
         } elsif ($conv eq 'r') {
             my $val = $p->total_remaining;
             if (defined $val) {
                 $val = 1 if $val < 1; 
                 $data = Time::Duration::concise(Time::Duration::duration($val));
             } else {
                 $data = '?';
             }
             $width //= -8;
         } elsif ($conv eq 'R') {
             my $val = $p->total_remaining;
             if (defined $val) {
                 $val = 1 if $val < 1; 
                 $data = Time::Duration::concise(Time::Duration::duration($val)).
                     " left"; 
             } else {
                 $val = $p->elapsed;
                 $val = 1 if $val < 1; 
                 $data = Time::Duration::concise(Time::Duration::duration($val)).
                     " elapsed"; 
             }
             $width //= -(8 + 1 + 7);
         } else {
             $fmt = '%s';
             $data = $all;
         }
 
         $sconv //= 's';
         $dot = "." if $sconv eq 'f';
         $fmt //= join("", grep {defined} ("%", $width, $dot, $prec, $sconv));
 
         sprintf $fmt, $data;
 
     };
     $template =~ s{$re}{$sub->(%args, indicator=>$self)}egox;
 
     $template;
 }
 
 1;
 
 __END__
 
### Progress/Any/Output.pm ###
 package Progress::Any::Output;
 
 our $DATE = '2015-01-27'; 
 our $VERSION = '0.20'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Progress::Any;
 
 sub import {
     my $self = shift;
     __PACKAGE__->set(@_) if @_;
 }
 
 sub _set_or_add {
     my $class = shift;
     my $which = shift;
 
     my $opts;
     if (@_ && ref($_[0]) eq 'HASH') {
         $opts = shift;
     } else {
         $opts = {};
     }
 
     my $output = shift or die "Please specify output name";
     $output =~ /\A(?:\w+(::\w+)*)?\z/ or die "Invalid output syntax '$output'";
 
     my $task = $opts->{task} // "";
 
     my $outputo;
     unless (ref $outputo) {
         my $outputpm = $output; $outputpm =~ s!::!/!g; $outputpm .= ".pm";
         require "Progress/Any/Output/$outputpm";
         no strict 'refs';
         $outputo = "Progress::Any::Output::$output"->new(@_);
     }
 
     if ($which eq 'set') {
         $Progress::Any::outputs{$task} = [$outputo];
     } else {
         $Progress::Any::outputs{$task} //= [];
         push @{ $Progress::Any::outputs{$task} }, $outputo;
     }
 
     $outputo;
 }
 
 sub set {
     my $class = shift;
     $class->_set_or_add('set', @_);
 }
 
 sub add {
     my $class = shift;
     $class->_set_or_add('add', @_);
 }
 
 1;
 
 __END__
 
### Progress/Any/Output/Null.pm ###
 package Progress::Any::Output::Null;
 
 use 5.010;
 use strict;
 use warnings;
 
 our $VERSION = '0.20'; 
 
 sub new {
     my ($class, %args) = @_;
     bless \%args, $class;
 }
 
 sub update {
     1;
 }
 
 1;
 
 __END__
 
### Progress/Any/Output/TermProgressBarColor.pm ###
 package Progress::Any::Output::TermProgressBarColor;
 
 our $DATE = '2015-08-29'; 
 our $VERSION = '0.21'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Color::ANSI::Util qw(ansifg ansibg);
 require Win32::Console::ANSI if $^O =~ /Win/;
 
 $|++;
 
 my ($ph1, $ph2);
 
 sub _patch {
     my $out = shift;
 
     return if $ph1;
     require Monkey::Patch::Action;
     $ph1 = Monkey::Patch::Action::patch_package(
         'Log::Any::Adapter::Screen', 'hook_before_log', 'replace',
         sub {
             $out->cleanup;
             $Progress::Any::output_data{"$out"}{force_update} = 1;
         }
     ) if defined &{"Log::Any::Adapter::Screen::hook_before_log"};
     $ph2 = Monkey::Patch::Action::patch_package(
         'Log::Any::Adapter::Screen', 'hook_after_log', 'replace',
         sub {
             my ($self, $msg) = @_;
             print { $self->{_fh} } "\n" unless $msg =~ /\R\z/;
             $out->keep_delay_showing if $out->{show_delay};
         }
     ) if defined &{"Log::Any::Adapter::Screen::hook_after_log"};
 }
 
 sub _unpatch {
     undef $ph1;
     undef $ph2;
 }
 
 sub new {
     my ($class, %args0) = @_;
 
     my %args;
 
     $args{width} = delete($args0{width});
     if (!defined($args{width})) {
         my ($cols, $rows);
         if ($ENV{COLUMNS}) {
             $cols = $ENV{COLUMNS};
         } elsif (eval { require Term::Size; 1 }) {
             ($cols, $rows) = Term::Size::chars();
         } else {
             $cols = 80;
         }
         $args{width} = $^O =~ /Win/ ? $cols-1 : $cols;
     }
 
     $args{fh} = delete($args0{fh});
     $args{fh} //= \*STDOUT;
 
     $args{show_delay} = delete($args0{show_delay});
 
     $args{wide} = delete($args0{wide});
 
     keys(%args0) and die "Unknown output parameter(s): ".
         join(", ", keys(%args0));
 
     $args{_last_hide_time} = time();
 
     require Text::ANSI::NonWideUtil;
     if ($args{wide}) {
         require Text::ANSI::WideUtil;
     }
 
     my $self = bless \%args, $class;
     $self->_patch;
     $self;
 }
 
 sub update {
     my ($self, %args) = @_;
 
     my $now = time();
 
     if (defined $self->{show_delay}) {
         return if $now - $self->{show_delay} < $self->{_last_hide_time};
     }
 
     my $ll = $self->{_lastlen};
     if (defined $self->{_lastlen}) {
         print { $self->{fh} } "\b" x $self->{_lastlen};
         undef $self->{_lastlen};
     }
 
     my $p = $args{indicator};
     my $tottgt = $p->total_target;
     my $totpos = $p->total_pos;
     my $is_complete = $p->{state} eq 'finished' ||
         defined($tottgt) && $tottgt > 0 && $totpos == $tottgt;
     if ($is_complete) {
         if ($ll) {
             my $fh = $self->{fh};
             print $fh " " x $ll, "\b" x $ll;
             $self->{_last_hide_time} = $now;
         }
         return;
     }
 
     my $bar;
     my $bar_pct = $p->fill_template("%p%% ", %args);
 
     my $bar_eta = $p->fill_template("%R", %args);
 
     my $bar_bar = "";
     my $bwidth = $self->{width} - length($bar_pct) - length($bar_eta) - 2;
     if ($bwidth > 0) {
         if ($tottgt) {
             my $bfilled = int($totpos / $tottgt * $bwidth);
             $bfilled = $bwidth if $bfilled > $bwidth;
             $bar_bar = ("=" x $bfilled) . (" " x ($bwidth-$bfilled));
 
             my $message = $args{message};
         } else {
             my $bfilled = int(0.15 * $bwidth);
             $bfilled = 1 if $bfilled < 1;
             $self->{_x}++;
             if ($self->{_x} > $bwidth-$bfilled) {
                 $self->{_x} = 0;
             }
             $bar_bar = (" " x $self->{_x}) . ("=" x $bfilled) .
                 (" " x ($bwidth-$self->{_x}-$bfilled));
         }
 
         my $msg = $args{message};
         if (defined $msg) {
             if ($msg =~ m!</elspan!) {
                 require String::Elide::Parts;
                 $msg = String::Elide::Parts::elide($msg, $bwidth);
             }
             my $mwidth;
             if ($self->{wide}) {
                 $msg = Text::ANSI::WideUtil::ta_mbtrunc($msg, $bwidth);
                 $mwidth = Text::ANSI::WideUtil::ta_mbswidth($msg);
             } else {
                 $msg = Text::ANSI::NonWideUtil::ta_trunc($msg, $bwidth);
                 $mwidth = Text::ANSI::NonWideUtil::ta_length($msg);
             }
             $bar_bar = ansifg("808080") . $msg . ansifg("ff8000") .
                 substr($bar_bar, $mwidth);
         }
 
         $bar_bar = ansifg("ff8000") . $bar_bar;
     }
 
     $bar = join(
         "",
         ansifg("ffff00"), $bar_pct,
         "[$bar_bar]",
         ansifg("ffff00"), $bar_eta,
         "\e[0m",
     );
     print { $self->{fh} } $bar;
 
     $self->{_lastlen} = Text::ANSI::NonWideUtil::ta_length($bar);
 }
 
 sub cleanup {
     my ($self) = @_;
 
 
     my $ll = $self->{_lastlen};
     return unless $ll;
     print { $self->{fh} } "\b" x $ll, " " x $ll, "\b" x $ll;
 }
 
 sub keep_delay_showing {
     my $self = shift;
 
     $self->{_last_hide_time} = time();
 }
 
 sub DESTROY {
     my $self = shift;
     $self->_unpatch;
 }
 
 1;
 
 __END__
 
### Regexp/Stringify.pm ###
 package Regexp::Stringify;
 
 our $DATE = '2015-09-04'; 
 our $VERSION = '0.04'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use re qw(regexp_pattern);
 use Version::Util qw(version_ge);
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(stringify_regexp);
 
 our %SPEC;
 
 $SPEC{stringify_regexp} = {
     v => 1.1,
     summary => 'Stringify a Regexp object',
     description => <<'_',
 
 This routine is an alternative to Perl's default stringification of Regexp
 object (i.e.:`"$re"`) and has some features/options, e.g.: producing regexp
 string that is compatible with certain perl versions.
 
 If given a string (or other non-Regexp object), will return it as-is.
 
 _
     args => {
         regexp => {
             schema => 're*',
             req => 1,
             pos => 0,
         },
         plver => {
             summary => 'Target perl version',
             schema => 'str*',
             description => <<'_',
 
 Try to produce a regexp object compatible with a certain perl version (should at
 least be >= 5.10).
 
 For example, in perl 5.14 regex stringification changes, e.g. `qr/hlagh/i` would
 previously be stringified as `(?i-xsm:hlagh)`, but now it's stringified as
 `(?^i:hlagh)`. If you set `plver` to 5.10 or 5.12, then this routine will
 still produce the former. It will also ignore regexp modifiers that are
 introduced in newer perls.
 
 Note that not all regexp objects are translatable to older perls, e.g. if they
 contain constructs not known to older perls like `(^...)` before perl 5.14.
 
 _
         },
         with_qr => {
             schema  => 'bool',
             description => <<'_',
 
 If you set this to 1, then `qr/a/i` will be stringified as `'qr/a/i'` instead as
 `'(^i:a)'`. The resulting string can then be eval-ed to recreate the Regexp
 object.
 
 _
         },
     },
     result_naked => 1,
     result => {
         schema => 'str*',
     },
 };
 sub stringify_regexp {
     my %args = @_;
 
     my $re = $args{regexp};
     return $re unless ref($re) eq 'Regexp';
     my $plver = $args{plver} // $^V;
 
     my ($pat, $mod) = regexp_pattern($re);
 
     my $ge_5140 = version_ge($plver, 5.014);
     unless ($ge_5140) {
         $mod =~ s/[adlu]//g;
     }
 
     if ($args{with_qr}) {
         return "qr($pat)$mod";
     } else {
         if ($ge_5140) {
             return "(^$mod:$pat)";
         } else {
             return "(?:(?$mod-)$pat)";
         }
     }
 }
 
 1;
 
 __END__
 
### Rinci.pm ###
 package Rinci;
 
 our $VERSION = '1.1.78'; 
 
 1;
 
 __END__
 
### Role/Tiny.pm ###
 package Role::Tiny;
 
 sub _getglob { \*{$_[0]} }
 sub _getstash { \%{"$_[0]::"} }
 
 use strict;
 use warnings;
 
 our $VERSION = '2.000001';
 $VERSION = eval $VERSION;
 
 our %INFO;
 our %APPLIED_TO;
 our %COMPOSED;
 our %COMPOSITE_INFO;
 our @ON_ROLE_CREATE;
 
 
 BEGIN {
   *_WORK_AROUND_BROKEN_MODULE_STATE = "$]" < 5.009 ? sub(){1} : sub(){0};
   *_MRO_MODULE = "$]" < 5.010 ? sub(){"MRO/Compat.pm"} : sub(){"mro.pm"};
 }
 
 sub Role::Tiny::__GUARD__::DESTROY {
   delete $INC{$_[0]->[0]} if @{$_[0]};
 }
 
 sub _load_module {
   (my $proto = $_[0]) =~ s/::/\//g;
   $proto .= '.pm';
   return 1 if $INC{$proto};
   return 1 if grep !/::$/, keys %{_getstash($_[0])||{}};
   my $guard = _WORK_AROUND_BROKEN_MODULE_STATE
     && bless([ $proto ], 'Role::Tiny::__GUARD__');
   require $proto;
   pop @$guard if _WORK_AROUND_BROKEN_MODULE_STATE;
   return 1;
 }
 
 sub import {
   my $target = caller;
   my $me = shift;
   strict->import;
   warnings->import;
   return if $me->is_role($target); 
   $INFO{$target}{is_role} = 1;
   my $stash = _getstash($target);
   foreach my $type (qw(before after around)) {
     *{_getglob "${target}::${type}"} = sub {
       require Class::Method::Modifiers;
       push @{$INFO{$target}{modifiers}||=[]}, [ $type => @_ ];
       return;
     };
   }
   *{_getglob "${target}::requires"} = sub {
     push @{$INFO{$target}{requires}||=[]}, @_;
     return;
   };
   *{_getglob "${target}::with"} = sub {
     $me->apply_roles_to_package($target, @_);
     return;
   };
   my @not_methods = (map { *$_{CODE}||() } grep !ref($_), values %$stash);
   @{$INFO{$target}{not_methods}={}}{@not_methods} = @not_methods;
   $APPLIED_TO{$target} = { $target => undef };
   $_->($target) for @ON_ROLE_CREATE;
 }
 
 sub role_application_steps {
   qw(_install_methods _check_requires _install_modifiers _copy_applied_list);
 }
 
 sub apply_single_role_to_package {
   my ($me, $to, $role) = @_;
 
   _load_module($role);
 
   die "This is apply_role_to_package" if ref($to);
   die "${role} is not a Role::Tiny" unless $me->is_role($role);
 
   foreach my $step ($me->role_application_steps) {
     $me->$step($to, $role);
   }
 }
 
 sub _copy_applied_list {
   my ($me, $to, $role) = @_;
   @{$APPLIED_TO{$to}||={}}{keys %{$APPLIED_TO{$role}}} = ();
 }
 
 sub apply_roles_to_object {
   my ($me, $object, @roles) = @_;
   die "No roles supplied!" unless @roles;
   my $class = ref($object);
   bless($_[1], $me->create_class_with_roles($class, @roles));
 }
 
 my $role_suffix = 'A000';
 sub _composite_name {
   my ($me, $superclass, @roles) = @_;
 
   my $new_name = join(
     '__WITH__', $superclass, my $compose_name = join '__AND__', @roles
   );
 
   if (length($new_name) > 252) {
     $new_name = $COMPOSED{abbrev}{$new_name} ||= do {
       my $abbrev = substr $new_name, 0, 250 - length $role_suffix;
       $abbrev =~ s/(?<!:):$//;
       $abbrev.'__'.$role_suffix++;
     };
   }
   return wantarray ? ($new_name, $compose_name) : $new_name;
 }
 
 sub create_class_with_roles {
   my ($me, $superclass, @roles) = @_;
 
   die "No roles supplied!" unless @roles;
 
   _load_module($superclass);
   {
     my %seen;
     $seen{$_}++ for @roles;
     if (my @dupes = grep $seen{$_} > 1, @roles) {
       die "Duplicated roles: ".join(', ', @dupes);
     }
   }
 
   my ($new_name, $compose_name) = $me->_composite_name($superclass, @roles);
 
   return $new_name if $COMPOSED{class}{$new_name};
 
   foreach my $role (@roles) {
     _load_module($role);
     die "${role} is not a Role::Tiny" unless $me->is_role($role);
   }
 
   require(_MRO_MODULE);
 
   my $composite_info = $me->_composite_info_for(@roles);
   my %conflicts = %{$composite_info->{conflicts}};
   if (keys %conflicts) {
     my $fail =
       join "\n",
         map {
           "Method name conflict for '$_' between roles "
           ."'".join(' and ', sort values %{$conflicts{$_}})."'"
           .", cannot apply these simultaneously to an object."
         } keys %conflicts;
     die $fail;
   }
 
   my @composable = map $me->_composable_package_for($_), reverse @roles;
 
   my @requires = grep {
     my $method = $_;
     !grep $_->can($method) && !$COMPOSED{role}{$_}{modifiers_only}{$method},
       @composable
   } @{$composite_info->{requires}};
 
   $me->_check_requires(
     $superclass, $compose_name, \@requires
   );
 
   *{_getglob("${new_name}::ISA")} = [ @composable, $superclass ];
 
   @{$APPLIED_TO{$new_name}||={}}{
     map keys %{$APPLIED_TO{$_}}, @roles
   } = ();
 
   $COMPOSED{class}{$new_name} = 1;
   return $new_name;
 }
 
 
 sub apply_role_to_package { shift->apply_single_role_to_package(@_) }
 
 sub apply_roles_to_package {
   my ($me, $to, @roles) = @_;
 
   return $me->apply_role_to_package($to, $roles[0]) if @roles == 1;
 
   my %conflicts = %{$me->_composite_info_for(@roles)->{conflicts}};
   my @have = grep $to->can($_), keys %conflicts;
   delete @conflicts{@have};
 
   if (keys %conflicts) {
     my $fail =
       join "\n",
         map {
           "Due to a method name conflict between roles "
           ."'".join(' and ', sort values %{$conflicts{$_}})."'"
           .", the method '$_' must be implemented by '${to}'"
         } keys %conflicts;
     die $fail;
   }
 
   my @role_methods = map $me->_concrete_methods_of($_), @roles;
   local @{$_}{@have} for @role_methods;
   delete @{$_}{@have} for @role_methods;
 
   if ($INFO{$to}) {
     delete $INFO{$to}{methods}; 
   }
 
   our %BACKCOMPAT_HACK;
   if($me ne __PACKAGE__
       and exists $BACKCOMPAT_HACK{$me} ? $BACKCOMPAT_HACK{$me} :
       $BACKCOMPAT_HACK{$me} =
         $me->can('role_application_steps')
           == \&role_application_steps
         && $me->can('apply_single_role_to_package')
           != \&apply_single_role_to_package
   ) {
     foreach my $role (@roles) {
       $me->apply_single_role_to_package($to, $role);
     }
   }
   else {
     foreach my $step ($me->role_application_steps) {
       foreach my $role (@roles) {
         $me->$step($to, $role);
       }
     }
   }
   $APPLIED_TO{$to}{join('|',@roles)} = 1;
 }
 
 sub _composite_info_for {
   my ($me, @roles) = @_;
   $COMPOSITE_INFO{join('|', sort @roles)} ||= do {
     foreach my $role (@roles) {
       _load_module($role);
     }
     my %methods;
     foreach my $role (@roles) {
       my $this_methods = $me->_concrete_methods_of($role);
       $methods{$_}{$this_methods->{$_}} = $role for keys %$this_methods;
     }
     my %requires;
     @requires{map @{$INFO{$_}{requires}||[]}, @roles} = ();
     delete $requires{$_} for keys %methods;
     delete $methods{$_} for grep keys(%{$methods{$_}}) == 1, keys %methods;
     +{ conflicts => \%methods, requires => [keys %requires] }
   };
 }
 
 sub _composable_package_for {
   my ($me, $role) = @_;
   my $composed_name = 'Role::Tiny::_COMPOSABLE::'.$role;
   return $composed_name if $COMPOSED{role}{$composed_name};
   $me->_install_methods($composed_name, $role);
   my $base_name = $composed_name.'::_BASE';
   _getstash($base_name);
   { no strict 'refs'; @{"${composed_name}::ISA"} = ( $base_name ); }
   my $modifiers = $INFO{$role}{modifiers}||[];
   my @mod_base;
   my @modifiers = grep !$composed_name->can($_),
     do { my %h; @h{map @{$_}[1..$#$_-1], @$modifiers} = (); keys %h };
   foreach my $modified (@modifiers) {
     push @mod_base, "sub ${modified} { shift->next::method(\@_) }";
   }
   my $e;
   {
     local $@;
     eval(my $code = join "\n", "package ${base_name};", @mod_base);
     $e = "Evaling failed: $@\nTrying to eval:\n${code}" if $@;
   }
   die $e if $e;
   $me->_install_modifiers($composed_name, $role);
   $COMPOSED{role}{$composed_name} = {
     modifiers_only => { map { $_ => 1 } @modifiers },
   };
   return $composed_name;
 }
 
 sub _check_requires {
   my ($me, $to, $name, $requires) = @_;
   return unless my @requires = @{$requires||$INFO{$name}{requires}||[]};
   if (my @requires_fail = grep !$to->can($_), @requires) {
     if (my $to_info = $INFO{$to}) {
       push @{$to_info->{requires}||=[]}, @requires_fail;
     } else {
       die "Can't apply ${name} to ${to} - missing ".join(', ', @requires_fail);
     }
   }
 }
 
 sub _concrete_methods_of {
   my ($me, $role) = @_;
   my $info = $INFO{$role};
   my $stash = _getstash($role);
   my $not_methods = { reverse %{$info->{not_methods}||{}} };
   $info->{methods} ||= +{
     map {
       my $code = *{$stash->{$_}}{CODE};
       ( ! $code or exists $not_methods->{$code} ) ? () : ($_ => $code)
     } grep !ref($stash->{$_}), keys %$stash
   };
 }
 
 sub methods_provided_by {
   my ($me, $role) = @_;
   die "${role} is not a Role::Tiny" unless $me->is_role($role);
   (keys %{$me->_concrete_methods_of($role)}, @{$INFO{$role}->{requires}||[]});
 }
 
 sub _install_methods {
   my ($me, $to, $role) = @_;
 
   my $info = $INFO{$role};
 
   my $methods = $me->_concrete_methods_of($role);
 
   my $stash = _getstash($to);
 
   my %has_methods;
   @has_methods{grep
     +(ref($stash->{$_}) || *{$stash->{$_}}{CODE}),
     keys %$stash
   } = ();
 
   foreach my $i (grep !exists $has_methods{$_}, keys %$methods) {
     no warnings 'once';
     my $glob = _getglob "${to}::${i}";
     *$glob = $methods->{$i};
 
     next
       unless $i =~ /^\(/
         && ((defined &overload::nil && $methods->{$i} == \&overload::nil)
             || (defined &overload::_nil && $methods->{$i} == \&overload::_nil));
 
     my $overload = ${ *{_getglob "${role}::${i}"}{SCALAR} };
     next
       unless defined $overload;
 
     *$glob = \$overload;
   }
 
   $me->_install_does($to);
 }
 
 sub _install_modifiers {
   my ($me, $to, $name) = @_;
   return unless my $modifiers = $INFO{$name}{modifiers};
   if (my $info = $INFO{$to}) {
     push @{$info->{modifiers}}, @{$modifiers||[]};
   } else {
     foreach my $modifier (@{$modifiers||[]}) {
       $me->_install_single_modifier($to, @$modifier);
     }
   }
 }
 
 my $vcheck_error;
 
 sub _install_single_modifier {
   my ($me, @args) = @_;
   defined($vcheck_error) or $vcheck_error = do {
     local $@;
     eval { Class::Method::Modifiers->VERSION(1.05); 1 }
       ? 0
       : $@
   };
   $vcheck_error and die $vcheck_error;
   Class::Method::Modifiers::install_modifier(@args);
 }
 
 my $FALLBACK = sub { 0 };
 sub _install_does {
   my ($me, $to) = @_;
 
   return if $me->is_role($to);
 
   my $does = $me->can('does_role');
   *{_getglob "${to}::does"} = $does unless $to->can('does');
 
   return
     if $to->can('DOES') and $to->can('DOES') != (UNIVERSAL->can('DOES') || 0);
 
   my $existing = $to->can('DOES') || $to->can('isa') || $FALLBACK;
   my $new_sub = sub {
     my ($proto, $role) = @_;
     $proto->$does($role) or $proto->$existing($role);
   };
   no warnings 'redefine';
   return *{_getglob "${to}::DOES"} = $new_sub;
 }
 
 sub does_role {
   my ($proto, $role) = @_;
   require(_MRO_MODULE);
   foreach my $class (@{mro::get_linear_isa(ref($proto)||$proto)}) {
     return 1 if exists $APPLIED_TO{$class}{$role};
   }
   return 0;
 }
 
 sub is_role {
   my ($me, $role) = @_;
   return !!($INFO{$role} && $INFO{$role}{is_role});
 }
 
 1;
 __END__
 
### Role/Tiny/With.pm ###
 package Role::Tiny::With;
 
 use strict;
 use warnings;
 
 our $VERSION = '2.000001';
 $VERSION = eval $VERSION;
 
 use Role::Tiny ();
 
 use Exporter 'import';
 our @EXPORT = qw( with );
 
 sub with {
     my $target = caller;
     Role::Tiny->apply_roles_to_package($target, @_)
 }
 
 1;
 
 
 
### Sah/Schema/Rinci.pm ###
 package Sah::Schema::Rinci;
 
 our $DATE = '2015-09-03'; 
 our $VERSION = '1.1.78'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 our %SCHEMAS;
 
 my %dh_props = (
     v => {},
     defhash_v => {},
     name => {},
     caption => {},
     summary => {},
     description => {},
     tags => {},
     default_lang => {},
     x => {},
 );
 
 $SCHEMAS{rinci} = [hash => {
     _ver => 1.1, 
     _prop => {
         %dh_props,
 
         entity_v => {},
         entity_date => {},
         links => {
             _elem_prop => {
                 %dh_props,
 
                 url => {},
             },
         },
     },
 }];
 
 $SCHEMAS{rinci_function} = [hash => {
     _ver => 1.1,
     _prop => {
         %dh_props,
 
         entity_v => {},
         entity_date => {},
         links => {},
 
         is_func => {},
         is_meth => {},
         is_class_meth => {},
         args => {
             _value_prop => {
                 %dh_props,
 
                 links => {},
 
                 schema => {},
                 filters => {},
                 default => {},
                 req => {},
                 pos => {},
                 greedy => {},
                 partial => {},
                 stream => {},
                 is_password => {},
                 cmdline_aliases => {
                     _value_prop => {
                         summary => {},
                         description => {},
                         schema => {},
                         code => {},
                         is_flag => {},
                     },
                 },
                 cmdline_on_getopt => {},
                 cmdline_prompt => {},
                 completion => {},
                 element_completion => {},
                 cmdline_src => {},
                 meta => 'fix',
                 element_meta => 'fix',
                 deps => {
                     _keys => {
                         arg => {},
                         all => {},
                         any => {},
                         none => {},
                     },
                 },
             },
         },
         args_as => {},
         args_rels => {},
         result => {
             _prop => {
                 %dh_props,
 
                 schema => {},
                 statuses => {
                     _value_prop => {
                         summary => {},
                         description => {},
                         schema => {},
                     },
                 },
                 partial => {},
                 stream => {},
             },
         },
         result_naked => {},
         examples => {
             _elem_prop => {
                 %dh_props,
 
                 args => {},
                 argv => {},
                 src => {},
                 src_plang => {},
                 status => {},
                 result => {},
                 test => {},
             },
         },
         features => {
             _keys => {
                 reverse => {},
                 tx => {},
                 dry_run => {},
                 pure => {},
                 immutable => {},
                 idempotent => {},
                 check_arg => {},
             },
         },
         deps => {
             _keys => {
                 all => {},
                 any => {},
                 none => {},
                 env => {},
                 prog => {},
                 pkg => {},
                 func => {},
                 code => {},
                 tmp_dir => {},
                 trash_dir => {},
             },
         },
     },
 }];
 $SCHEMAS{rinci_function}[1]{_prop}{args}{_value_prop}{meta} =
     $SCHEMAS{rinci_function}[1];
 $SCHEMAS{rinci_function}[1]{_prop}{args}{_value_prop}{element_meta} =
     $SCHEMAS{rinci_function}[1];
 
 
 $SCHEMAS{rinci_resmeta} = [hash => {
     _ver => 1.1,
     _prop => {
         %dh_props,
 
         perm_err => {},
         func => {}, 
         cmdline => {}, 
         logs => {},
         prev => {},
         results => {},
         part_start => {},
         part_len => {},
         len => {},
         stream => {},
     },
 }];
 
 
 1;
 
 __END__
 
### Scalar/Util/Numeric/PP.pm ###
 package Scalar::Util::Numeric::PP;
 
 our $DATE = '2015-06-16'; 
 our $VERSION = '0.03'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(
                        isint
                        isnum
                        isnan
                        isinf
                        isneg
                        isfloat
                );
 
 sub isint {
     local $_ = shift;
     return 0 unless defined;
     return 1 if /\A[+-]?(?:0|[1-9][0-9]*)\z/;
     0;
 }
 
 sub isnan($) {
     local $_ = shift;
     return 0 unless defined;
     return 1 if /\A\s*[+-]?nan\s*\z/i;
     0;
 }
 
 sub isinf($) {
     local $_ = shift;
     return 0 unless defined;
     return 1 if /\A\s*[+-]?inf(?:inity)?\s*\z/i;
     0;
 }
 
 sub isneg($) {
     local $_ = shift;
     return 0 unless defined;
     return 1 if /\A\s*-/;
     0;
 }
 
 sub isnum($) {
     local $_ = shift;
     return 0 unless defined;
     return 1 if isint($_);
     return 1 if isfloat($_);
     0;
 }
 
 sub isfloat($) {
     local $_ = shift;
     return 0 unless defined;
     return 1 if /\A[+-]?
                  (?: (?:0|[1-9][0-9]*)(\.[0-9]+)? | (\.[0-9]+) )
                  ([eE][+-]?[0-9]+)?\z/x && $1 || $2 || $3;
     return 1 if isnan($_) || isinf($_);
     0;
 }
 
 1;
 
 __END__
 
### String/Elide/Parts.pm ###
 package String::Elide::Parts;
 
 our $DATE = '2015-01-23'; 
 our $VERSION = '0.01'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(elide);
 
 sub _elide_part {
     my ($str, $len, $marker, $truncate) = @_;
 
     my $len_marker = length($marker);
     if ($len <= $len_marker) {
         return substr($marker, 0, $len);
     }
 
     if ($truncate eq 'left') {
         return $marker . substr($str, length($str) - $len+$len_marker);
     } elsif ($truncate eq 'middle') {
         my $left  = substr($str, 0,
                            ($len-$len_marker)/2);
         my $right = substr($str,
                            length($str) - ($len-$len_marker-length($left)));
         return $left . $marker . $right;
     } elsif ($truncate eq 'ends') {
         if ($len <= 2*$len_marker) {
             return substr($marker . $marker, 0, $len);
         }
         return $marker . substr($str, (length($str)-$len)/2 + $len_marker,
                                 $len-2*$len_marker) . $marker;
     } else { 
         return substr($str, 0, $len-$len_marker) . $marker;
     }
 }
 
 sub elide {
     my ($str, $len, $opts) = @_;
 
     $opts //= {};
     my $truncate  = $opts->{truncate} // 'right';
     my $marker = $opts->{marker} // '..';
 
     my @parts;
     my @parts_attrs;
     my $parts_len = 0;
     while ($str =~ m#<elspan([^>]*)>(.*?)</elspan>|(.*?)(?=<elspan)|(.*)#g) {
         if (defined $1) {
             next unless length $2;
             push @parts, $2;
             push @parts_attrs, $1;
         } elsif (defined $3) {
             next unless length $3;
             push @parts, $3;
             push @parts_attrs, undef;
         } elsif (defined $4) {
             next unless length $4;
             push @parts, $4;
             push @parts_attrs, undef;
         }
     }
     return "" unless @parts && $len > 0;
     for my $i (0..@parts-1) {
         $parts_len += length($parts[$i]);
         if (defined $parts_attrs[$i]) {
             my $attrs = {};
             $attrs->{truncate} = $1 // $2
                 if $parts_attrs[$i] =~ /\btruncate=(?:"([^"]*)"|(\S+))/;
             $attrs->{prio} = $1 // $2
                 if $parts_attrs[$i] =~ /\bprio(?:rity)?=(?:"([^"]*)"|(\S+))/;
             $parts_attrs[$i] = $attrs;
         } else {
             $parts_attrs[$i] = {prio=>1};
         }
     }
 
 
     my $flip = 0;
 
   PART:
     while (1) {
         if ($parts_len <= $len) {
             return join("", @parts);
         }
 
         my @indexes;
         my $highest_prio;
         for (@parts_attrs) {
             $highest_prio = $_->{prio} if !defined($highest_prio) ||
                 $highest_prio < $_->{prio};
         }
         for my $i (0..@parts_attrs-1) {
             push @indexes, $i if $parts_attrs[$i]{prio} == $highest_prio;
         }
 
         my $index;
         if ($truncate eq 'left') {
             $index = $indexes[0];
         } elsif ($truncate eq 'middle') {
             $index = $indexes[@indexes/2];
         } elsif ($truncate eq 'ends') {
             $index = $flip++ % 2 ? $indexes[0] : $indexes[-1];
         } else { 
             $index = $indexes[-1];
         }
 
         my $part_len = length($parts[$index]);
         if ($parts_len - $part_len >= $len) {
             $parts_len -= $part_len;
             splice @parts, $index, 1;
             splice @parts_attrs, $index, 1;
             next PART;
         }
 
         $parts[$index] = _elide_part(
             $parts[$index],
             $part_len - ($parts_len-$len),
             $marker,
             $parts_attrs[$index]{truncate} // $truncate,
         );
         return join("", @parts);
 
     } 
 }
 
 1;
 
 __END__
 
### String/Indent.pm ###
 package String::Indent;
 
 our $DATE = '2015-03-06'; 
 our $VERSION = '0.03'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        indent
                );
 
 sub indent {
     my ($indent, $str, $opts) = @_;
     $opts //= {};
 
     my $ibl = $opts->{indent_blank_lines} // 1;
     my $fli = $opts->{first_line_indent} // $indent;
     my $sli = $opts->{subsequent_lines_indent} // $indent;
 
     my $i = 0;
     $str =~ s/^([^\r\n]?)/$i++; !$ibl && !$1 ? "$1" : $i==1 ? "$fli$1" : "$sli$1"/egm;
     $str;
 }
 
 1;
 
 __END__
 
### String/LineNumber.pm ###
 package String::LineNumber;
 
 our $DATE = '2014-12-10'; 
 our $VERSION = '0.01'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        linenum
                );
 
 sub linenum {
     my ($str, $opts) = @_;
     $opts //= {};
     $opts->{width}      //= 4;
     $opts->{zeropad}    //= 0;
     $opts->{skip_empty} //= 1;
 
     my $i = 0;
     $str =~ s/^(([\t ]*\S)?.*)/
         sprintf(join("",
                      "%",
                      ($opts->{zeropad} && !($opts->{skip_empty}
                                                 && !defined($2)) ? "0" : ""),
                      $opts->{width}, "s",
                      "|%s"),
                 ++$i && $opts->{skip_empty} && !defined($2) ? "" : $i,
                 $1)/meg;
 
     $str;
 }
 
 1;
 
 __END__
 
### String/PerlQuote.pm ###
 package String::PerlQuote;
 
 our $DATE = '2014-12-10'; 
 our $VERSION = '0.01'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        single_quote
                        double_quote
                );
 
 my %esc = (
     "\a" => "\\a",
     "\b" => "\\b",
     "\t" => "\\t",
     "\n" => "\\n",
     "\f" => "\\f",
     "\r" => "\\r",
     "\e" => "\\e",
 );
 
 sub double_quote {
   local($_) = $_[0];
   s/([\\\"\@\$])/\\$1/g;
   return qq("$_") unless /[^\040-\176]/;  
 
   s/([\a\b\t\n\f\r\e])/$esc{$1}/g;
 
   s/([\0-\037])(?!\d)/sprintf('\\%o',ord($1))/eg;
 
   s/([\0-\037\177-\377])/sprintf('\\x%02X',ord($1))/eg;
   s/([^\040-\176])/sprintf('\\x{%X}',ord($1))/eg;
 
   return qq("$_");
 }
 
 sub single_quote {
   local($_) = $_[0];
   s/([\\'])/\\$1/g;
   return qq('$_');
 }
 1;
 
 __END__
 
### String/ShellQuote.pm ###
 
 
 package String::ShellQuote;
 
 use strict;
 use vars qw($VERSION @ISA @EXPORT);
 
 require Exporter;
 
 $VERSION	= '1.04';
 @ISA		= qw(Exporter);
 @EXPORT		= qw(shell_quote shell_quote_best_effort shell_comment_quote);
 
 sub croak {
     require Carp;
     goto &Carp::croak;
 }
 
 sub _shell_quote_backend {
     my @in = @_;
     my @err = ();
 
     if (0) {
 	require RS::Handy;
 	print RS::Handy::data_dump(\@in);
     }
 
     return \@err, '' unless @in;
 
     my $ret = '';
     my $saw_non_equal = 0;
     foreach (@in) {
 	if (!defined $_ or $_ eq '') {
 	    $_ = "''";
 	    next;
 	}
 
 	if (s/\x00//g) {
 	    push @err, "No way to quote string containing null (\\000) bytes";
 	}
 
     	my $escape = 0;
 
 
 	if (/=/) {
 	    if (!$saw_non_equal) {
 	    	$escape = 1;
 	    }
 	}
 	else {
 	    $saw_non_equal = 1;
 	}
 
 	if (m|[^\w!%+,\-./:=@^]|) {
 	    $escape = 1;
 	}
 
 	if ($escape
 		|| (!$saw_non_equal && /=/)) {
 
     	    s/'/'\\''/g;
 
     	    s|((?:'\\''){2,})|q{'"} . (q{'} x (length($1) / 4)) . q{"'}|ge;
 
 	    $_ = "'$_'";
 	    s/^''//;
 	    s/''$//;
 	}
     }
     continue {
 	$ret .= "$_ ";
     }
 
     chop $ret;
     return \@err, $ret;
 }
 
 
 sub shell_quote {
     my ($rerr, $s) = _shell_quote_backend @_;
 
     if (@$rerr) {
     	my %seen;
     	@$rerr = grep { !$seen{$_}++ } @$rerr;
 	my $s = join '', map { "shell_quote(): $_\n" } @$rerr;
 	chomp $s;
 	croak $s;
     }
     return $s;
 }
 
 
 sub shell_quote_best_effort {
     my ($rerr, $s) = _shell_quote_backend @_;
 
     return $s;
 }
 
 
 sub shell_comment_quote {
     return '' unless @_;
     unless (@_ == 1) {
 	croak "Too many arguments to shell_comment_quote "
 	    	    . "(got " . @_ . " expected 1)";
     }
     local $_ = shift;
     s/\n/\n#/g;
     return $_;
 }
 
 1;
 
 __END__
 
### String/Trim/More.pm ###
 package String::Trim::More;
 
 our $DATE = '2014-12-10'; 
 our $VERSION = '0.02'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        ltrim
                        rtrim
                        trim
                        ltrim_lines
                        rtrim_lines
                        trim_lines
                        trim_blank_lines
 
                        ellipsis
                );
 
 sub ltrim {
     my $str = shift;
     $str =~ s/\A\s+//s;
     $str;
 }
 
 sub rtrim {
     my $str = shift;
     $str =~ s/\s+\z//s;
     $str;
 }
 
 sub trim {
     my $str = shift;
     $str =~ s/\A\s+//s;
     $str =~ s/\s+\z//s;
     $str;
 }
 
 sub ltrim_lines {
     my $str = shift;
     $str =~ s/^[ \t]+//mg; 
     $str;
 }
 
 sub rtrim_lines {
     my $str = shift;
     $str =~ s/[ \t]+$//mg;
     $str;
 }
 
 sub trim_lines {
     my $str = shift;
     $str =~ s/^[ \t]+//mg;
     $str =~ s/[ \t]+$//mg;
     $str;
 }
 
 sub trim_blank_lines {
     local $_ = shift;
     return $_ unless defined;
     s/\A(?:\n\s*)+//;
     s/(?:\n\s*){2,}\z/\n/;
     $_;
 }
 
 sub ellipsis {
     my ($str, $maxlen, $ellipsis) = @_;
     $maxlen   //= 80;
     $ellipsis //= "...";
 
     if (length($str) <= $maxlen) {
         return $str;
     } else {
         return substr($str, 0, $maxlen-length($ellipsis)) . $ellipsis;
     }
 }
 
 1;
 
 __END__
 
### String/Wildcard/Bash.pm ###
 package String::Wildcard::Bash;
 
 use 5.010001;
 use strict;
 use warnings;
 
 our $VERSION = '0.03'; 
 
 use Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        $RE_WILDCARD_BASH
                        contains_wildcard
                        convert_wildcard_to_sql
                );
 
 our $RE_WILDCARD_BASH =
     qr(
           # non-escaped brace expression, with at least one comma
           (?P<brace>
               (?<!\\)(?:\\\\)*\{
               (?:           \\\\ | \\\{ | \\\} | [^\\\{\}] )*
               (?:, (?:  \\\\ | \\\{ | \\\} | [^\\\{\}] )* )+
               (?<!\\)(?:\\\\)*\}
           )
       |
           # non-escaped brace expression, to catch * or ? or [...] inside so
           # they don't go to below pattern, because bash doesn't consider them
           # wildcards, e.g. '/{et?,us*}' expands to '/etc /usr', but '/{et?}'
           # doesn't expand at all to /etc.
           (?P<braceno>
               (?<!\\)(?:\\\\)*\{
               (?:           \\\\ | \\\{ | \\\} | [^\\\{\}] )*
               (?<!\\)(?:\\\\)*\}
           )
       |
           (?P<class>
               # non-empty, non-escaped character class
               (?<!\\)(?:\\\\)*\[
               (?:  \\\\ | \\\[ | \\\] | [^\\\[\]] )+
               (?<!\\)(?:\\\\)*\]
           )
       |
           (?P<joker>
               # non-escaped * and ?
               (?<!\\)(?:\\\\)*[*?]
           )
       |
           (?P<sql_wc>
               # non-escaped % and ?
               (?<!\\)(?:\\\\)*[%_]
           )
       )ox;
 
 sub contains_wildcard {
     my $str = shift;
 
     while ($str =~ /$RE_WILDCARD_BASH/go) {
         my %m = %+;
         return 1 if $m{brace} || $m{class} || $m{joker};
     }
     0;
 }
 
 sub convert_wildcard_to_sql {
     my $str = shift;
 
     $str =~ s/$RE_WILDCARD_BASH/
         if ($+{joker}) {
             if ($+{joker} eq '*') {
                 "%";
             } else {
                 "_";
             }
         } elsif ($+{sql_wc}) {
             "\\$+{sql_wc}";
         } else {
             $&;
         }
     /eg;
 
     $str;
 }
 
 1;
 
 __END__
 
### Sub/Defer.pm ###
 package Sub::Defer;
 
 use Moo::_strictures;
 use Exporter qw(import);
 use Moo::_Utils qw(_getglob _install_coderef);
 use Scalar::Util qw(weaken);
 
 our $VERSION = '2.000002';
 $VERSION = eval $VERSION;
 
 our @EXPORT = qw(defer_sub undefer_sub undefer_all);
 our @EXPORT_OK = qw(undefer_package);
 
 our %DEFERRED;
 
 sub undefer_sub {
   my ($deferred) = @_;
   my ($target, $maker, $undeferred_ref) = @{
     $DEFERRED{$deferred}||return $deferred
   };
   return ${$undeferred_ref}
     if ${$undeferred_ref};
   ${$undeferred_ref} = my $made = $maker->();
 
   if (defined($target) && $deferred eq *{_getglob($target)}{CODE}||'') {
     no warnings 'redefine';
 
     *{_getglob($target)} = $made;
   }
   $DEFERRED{$made} = $DEFERRED{$deferred};
   weaken $DEFERRED{$made}
     unless $target;
 
   return $made;
 }
 
 sub undefer_all {
   undefer_sub($_) for keys %DEFERRED;
   return;
 }
 
 sub undefer_package {
   my $package = shift;
   my @subs = grep { $DEFERRED{$_}[0] =~ /^${package}::[^:]+$/ } keys %DEFERRED;
   undefer_sub($_) for @subs;
   return;
 }
 
 sub defer_info {
   my ($deferred) = @_;
   my $info = $DEFERRED{$deferred||''} or return undef;
   [ @$info ];
 }
 
 sub defer_sub {
   my ($target, $maker) = @_;
   my $undeferred;
   my $deferred_info;
   my $deferred = sub {
     $undeferred ||= undefer_sub($deferred_info->[3]);
     goto &$undeferred;
   };
   $deferred_info = [ $target, $maker, \$undeferred, $deferred ];
   weaken($deferred_info->[3]);
   weaken($DEFERRED{$deferred} = $deferred_info);
   _install_coderef($target => $deferred) if defined $target;
   return $deferred;
 }
 
 sub CLONE {
   %DEFERRED = map { defined $_ && $_->[3] ? ($_->[3] => $_) : () } values %DEFERRED;
   foreach my $info (values %DEFERRED) {
     weaken($info)
       unless $info->[0] && ${$info->[2]};
   }
 }
 
 1;
 __END__
 
### Sub/Delete.pm ###
 use 5.008003;
 
 package Sub::Delete;
 
 $VERSION = '1.00002';
 @EXPORT = delete_sub;
 
 use Exporter 5.57 'import';
 use constant point0 => 0+$] eq 5.01;
 
 sub strict_eval($) {
  local %^H if point0;
  local *@;
  use
   strict 'vars';
  local $SIG{__WARN__} = sub {};
  eval shift
 }
 
 my %sigils = qw( SCALAR $  ARRAY @  HASH % );
 
 sub delete_sub {
 	my $sub = shift;
 	my($stashname, $key) = $sub =~ /(.*::)((?:(?!::).)*)\z/s
 		? ($1,$2) : (caller()."::", $sub);
 	exists +(my $stash = \%$stashname)->{$key} or return;
 	ref $stash->{$key} eq 'SCALAR' and  
 		delete $stash->{$key}, return;
 	my $globname = "$stashname$key"; 
 	my $glob = *$globname; 
 	defined *$glob{CODE} or return;  
 	my $check_importedness
 	 = $stashname =~ /^(?:(?!\d)\w*(?:::\w*)*)\z/
 	   && $key    =~ /^(?!\d)\w+\z/;
 	my %imported_slots;
 	my $package;
 	if($check_importedness) {
 		$package = substr $stashname, 0, -2;
 		for (qw "SCALAR ARRAY HASH") {
 			defined *$glob{$_} or next;
 			$imported_slots{$_} = strict_eval
 			  "package $package; 0 && $sigils{$_}$key; 1"
 		}
 	}
         delete $stash->{$key};
 	keys %imported_slots == 1 and exists $imported_slots{SCALAR}
 	 and !$imported_slots{SCALAR} and Internals'SvREFCNT $$glob =>== 1
 	 and !defined *$glob{IO} and !defined *$glob{FORMAT}
 	 and return; 
 	my $newglob = \*$globname;
 	local *alias = *$newglob;
 	defined *$glob{$_} and (
 	 !$check_importedness || $imported_slots{$_}
 	  ? *$newglob
 	  : *alias
 	) = *$glob{$_}
 		for qw "SCALAR ARRAY HASH";
 	defined *$glob{$_} and *$newglob = *$glob{$_}
 		for qw "IO FORMAT";
 	return 
 }
 
 1;
 
 __END__
 
### Sub/Exporter/Progressive.pm ###
 package Sub::Exporter::Progressive;
 
 use strict;
 use warnings;
 
 our $VERSION = '0.001011';
 
 use Carp ();
 use List::Util ();
 
 sub import {
    my ($self, @args) = @_;
 
    my $inner_target = caller;
    my $export_data = sub_export_options($inner_target, @args);
 
    my $full_exporter;
    no strict 'refs';
    @{"${inner_target}::EXPORT_OK"} = @{$export_data->{exports}};
    @{"${inner_target}::EXPORT"} = @{$export_data->{defaults}};
    %{"${inner_target}::EXPORT_TAGS"} = %{$export_data->{tags}};
    *{"${inner_target}::import"} = sub {
       use strict;
       my ($self, @args) = @_;
 
       if (List::Util::first { ref || !m/ \A [:-]? \w+ \z /xm } @args) {
          Carp::croak 'your usage of Sub::Exporter::Progressive requires Sub::Exporter to be installed'
             unless eval { require Sub::Exporter };
          $full_exporter ||= Sub::Exporter::build_exporter($export_data->{original});
 
          goto $full_exporter;
       } elsif (defined(my $num = List::Util::first { !ref and m/^\d/ } @args)) {
          die "cannot export symbols with a leading digit: '$num'";
       } else {
          require Exporter;
          s/ \A - /:/xm for @args;
          @_ = ($self, @args);
          goto \&Exporter::import;
       }
    };
    return;
 }
 
 my $too_complicated = <<'DEATH';
 You are using Sub::Exporter::Progressive, but the features your program uses from
 Sub::Exporter cannot be implemented without Sub::Exporter, so you might as well
 just use vanilla Sub::Exporter
 DEATH
 
 sub sub_export_options {
    my ($inner_target, $setup, $options) = @_;
 
    my @exports;
    my @defaults;
    my %tags;
 
    if ($setup eq '-setup') {
       my %options = %$options;
 
       OPTIONS:
       for my $opt (keys %options) {
          if ($opt eq 'exports') {
 
             Carp::croak $too_complicated if ref $options{exports} ne 'ARRAY';
             @exports = @{$options{exports}};
             Carp::croak $too_complicated if List::Util::first { ref } @exports;
 
          } elsif ($opt eq 'groups') {
             %tags = %{$options{groups}};
             for my $tagset (values %tags) {
                Carp::croak $too_complicated if List::Util::first { / \A - (?! all \b ) /x || ref } @{$tagset};
             }
             @defaults = @{$tags{default} || [] };
          } else {
             Carp::croak $too_complicated;
          }
       }
       @{$_} = map { / \A  [:-] all \z /x ? @exports : $_ } @{$_} for \@defaults, values %tags;
       $tags{all} ||= [ @exports ];
       my %exports = map { $_ => 1 } @exports;
       my @errors = grep { not $exports{$_} } @defaults;
       Carp::croak join(', ', @errors) . " is not exported by the $inner_target module\n" if @errors;
    }
 
    return {
       exports => \@exports,
       defaults => \@defaults,
       original => $options,
       tags => \%tags,
    };
 }
 
 1;
 
### Sub/Install.pm ###
 use strict;
 use warnings;
 package Sub::Install;
 $Sub::Install::VERSION = '0.928';
 use Carp;
 use Scalar::Util ();
 
 
 sub _name_of_code {
   my ($code) = @_;
   require B;
   my $name = B::svref_2object($code)->GV->NAME;
   return $name unless $name =~ /\A__ANON__/;
   return;
 }
 
 sub _CODELIKE {
   (Scalar::Util::reftype($_[0])||'') eq 'CODE'
   || Scalar::Util::blessed($_[0])
   && (overload::Method($_[0],'&{}') ? $_[0] : undef);
 }
 
 sub _build_public_installer {
   my ($installer) = @_;
 
   sub {
     my ($arg) = @_;
     my ($calling_pkg) = caller(0);
 
     for (qw(into from)) { $arg->{$_} = $calling_pkg unless $arg->{$_} }
 
     Carp::croak "named argument 'code' is not optional" unless $arg->{code};
 
     if (_CODELIKE($arg->{code})) {
       $arg->{as} ||= _name_of_code($arg->{code});
     } else {
       Carp::croak
         "couldn't find subroutine named $arg->{code} in package $arg->{from}"
         unless my $code = $arg->{from}->can($arg->{code});
 
       $arg->{as}   = $arg->{code} unless $arg->{as};
       $arg->{code} = $code;
     }
 
     Carp::croak "couldn't determine name under which to install subroutine"
       unless $arg->{as};
 
     $installer->(@$arg{qw(into as code) });
   }
 }
 
 
 my $_misc_warn_re;
 my $_redef_warn_re;
 BEGIN {
   $_misc_warn_re = qr/
     Prototype\ mismatch:\ sub\ .+?  |
     Constant subroutine .+? redefined
   /x;
   $_redef_warn_re = qr/Subroutine\ .+?\ redefined/x;
 }
 
 my $eow_re;
 BEGIN { $eow_re = qr/ at .+? line \d+\.\Z/ };
 
 sub _do_with_warn {
   my ($arg) = @_;
   my $code = delete $arg->{code};
   my $wants_code = sub {
     my $code = shift;
     sub {
       my $warn = $SIG{__WARN__} ? $SIG{__WARN__} : sub { warn @_ }; 
       local $SIG{__WARN__} = sub {
         my ($error) = @_;
         for (@{ $arg->{suppress} }) {
             return if $error =~ $_;
         }
         for (@{ $arg->{croak} }) {
           if (my ($base_error) = $error =~ /\A($_) $eow_re/x) {
             Carp::croak $base_error;
           }
         }
         for (@{ $arg->{carp} }) {
           if (my ($base_error) = $error =~ /\A($_) $eow_re/x) {
             return $warn->(Carp::shortmess $base_error);
           }
         }
         ($arg->{default} || $warn)->($error);
       };
       $code->(@_);
     };
   };
   return $wants_code->($code) if $code;
   return $wants_code;
 }
 
 sub _installer {
   sub {
     my ($pkg, $name, $code) = @_;
     no strict 'refs'; 
     *{"$pkg\::$name"} = $code;
     return $code;
   }
 }
 
 BEGIN {
   *_ignore_warnings = _do_with_warn({
     carp => [ $_misc_warn_re, $_redef_warn_re ]
   });
 
   *install_sub = _build_public_installer(_ignore_warnings(_installer));
 
   *_carp_warnings =  _do_with_warn({
     carp     => [ $_misc_warn_re ],
     suppress => [ $_redef_warn_re ],
   });
 
   *reinstall_sub = _build_public_installer(_carp_warnings(_installer));
 
   *_install_fatal = _do_with_warn({
     code     => _installer,
     croak    => [ $_redef_warn_re ],
   });
 }
 
 
 sub install_installers {
   my ($into) = @_;
 
   for my $method (qw(install_sub reinstall_sub)) {
     my $code = sub {
       my ($package, $subs) = @_;
       my ($caller) = caller(0);
       my $return;
       for (my ($name, $sub) = %$subs) {
         $return = Sub::Install->can($method)->({
           code => $sub,
           from => $caller,
           into => $package,
           as   => $name
         });
       }
       return $return;
     };
     install_sub({ code => $code, into => $into, as => $method });
   }
 }
 
 
 sub exporter {
   my ($arg) = @_;
 
   my %is_exported = map { $_ => undef } @{ $arg->{exports} };
 
   sub {
     my $class = shift;
     my $target = caller;
     for (@_) {
       Carp::croak "'$_' is not exported by $class" if !exists $is_exported{$_};
       install_sub({ code => $_, from => $class, into => $target });
     }
   }
 }
 
 BEGIN { *import = exporter({ exports => [ qw(install_sub reinstall_sub) ] }); }
 
 
 1;
 
 __END__
 
### Sub/Quote.pm ###
 package Sub::Quote;
 
 sub _clean_eval { eval $_[0] }
 
 use Moo::_strictures;
 
 use Sub::Defer qw(defer_sub);
 use Scalar::Util qw(weaken);
 use Exporter qw(import);
 use B ();
 BEGIN {
   *_HAVE_PERLSTRING = defined &B::perlstring ? sub(){1} : sub(){0};
 }
 
 our $VERSION = '2.000002';
 $VERSION = eval $VERSION;
 
 our @EXPORT = qw(quote_sub unquote_sub quoted_from_sub qsub);
 our @EXPORT_OK = qw(quotify capture_unroll inlinify);
 
 our %QUOTED;
 
 sub quotify {
   ! defined $_[0]     ? 'undef()'
   : _HAVE_PERLSTRING  ? B::perlstring($_[0])
   : qq["\Q$_[0]\E"];
 }
 
 sub capture_unroll {
   my ($from, $captures, $indent) = @_;
   join(
     '',
     map {
       /^([\@\%\$])/
         or die "capture key should start with \@, \% or \$: $_";
       (' ' x $indent).qq{my ${_} = ${1}{${from}->{${\quotify $_}}};\n};
     } keys %$captures
   );
 }
 
 sub inlinify {
   my ($code, $args, $extra, $local) = @_;
   my $do = 'do { '.($extra||'');
   if ($code =~ s/^(\s*package\s+([a-zA-Z0-9:]+);)//) {
     $do .= $1;
   }
   if ($code =~ s{
     \A((?:\#\ BEGIN\ quote_sub\ PRELUDE\n.*?\#\ END\ quote_sub\ PRELUDE\n)?\s*)
     (^\s*) my \s* \(([^)]+)\) \s* = \s* \@_;
   }{}xms) {
     my ($pre, $indent, $code_args) = ($1, $2, $3);
     $do .= $pre;
     if ($code_args ne $args) {
       $do .= $indent . 'my ('.$code_args.') = ('.$args.'); ';
     }
   }
   elsif ($local || $args ne '@_') {
     $do .= ($local ? 'local ' : '').'@_ = ('.$args.'); ';
   }
   $do.$code.' }';
 }
 
 sub quote_sub {
   my $options =
     (ref($_[-1]) eq 'HASH' and ref($_[-2]) eq 'HASH')
       ? pop
       : {};
   my $captures = ref($_[-1]) eq 'HASH' ? pop : undef;
   undef($captures) if $captures && !keys %$captures;
   my $code = pop;
   my $name = $_[0];
   my ($package, $hints, $bitmask, $hintshash) = (caller(0))[0,8,9,10];
   my $context
     ="# BEGIN quote_sub PRELUDE\n"
     ."package $package;\n"
     ."BEGIN {\n"
     ."  \$^H = ".quotify($hints).";\n"
     ."  \${^WARNING_BITS} = ".quotify($bitmask).";\n"
     ."  \%^H = (\n"
     . join('', map
      "    ".quotify($_)." => ".quotify($hintshash->{$_}).",",
       keys %$hintshash)
     ."  );\n"
     ."}\n"
     ."# END quote_sub PRELUDE\n";
   $code = "$context$code";
   my $quoted_info;
   my $unquoted;
   my $deferred = defer_sub +($options->{no_install} ? undef : $name) => sub {
     $unquoted if 0;
     unquote_sub($quoted_info->[4]);
   };
   $quoted_info = [ $name, $code, $captures, \$unquoted, $deferred ];
   weaken($quoted_info->[3]);
   weaken($quoted_info->[4]);
   weaken($QUOTED{$deferred} = $quoted_info);
   return $deferred;
 }
 
 sub quoted_from_sub {
   my ($sub) = @_;
   my $quoted_info = $QUOTED{$sub||''} or return undef;
   my ($name, $code, $captured, $unquoted, $deferred) = @{$quoted_info};
   $unquoted &&= $$unquoted;
   if (($deferred && $deferred eq $sub)
       || ($unquoted && $unquoted eq $sub)) {
     return [ $name, $code, $captured, $unquoted, $deferred ];
   }
   return undef;
 }
 
 sub unquote_sub {
   my ($sub) = @_;
   my $quoted = $QUOTED{$sub} or return undef;
   my $unquoted = $quoted->[3];
   unless ($unquoted && $$unquoted) {
     my ($name, $code, $captures) = @$quoted;
 
     my $make_sub = "{\n";
 
     my %captures = $captures ? %$captures : ();
     $captures{'$_UNQUOTED'} = \$unquoted;
     $captures{'$_QUOTED'} = \$quoted;
     $make_sub .= capture_unroll("\$_[1]", \%captures, 2);
 
     $make_sub .= (
       $name
         ? "  no warnings 'closure';\n  sub ${name} {\n"
         : "  \$\$_UNQUOTED = sub {\n"
     );
     $make_sub .= "  \$_QUOTED if 0;\n";
     $make_sub .= "  \$_UNQUOTED if 0;\n";
     $make_sub .= $code;
     $make_sub .= "  }".($name ? '' : ';')."\n";
     if ($name) {
       $make_sub .= "  \$\$_UNQUOTED = \\&${name}\n";
     }
     $make_sub .= "}\n1;\n";
     $ENV{SUB_QUOTE_DEBUG} && warn $make_sub;
     {
       no strict 'refs';
       local *{$name} if $name;
       my ($success, $e);
       {
         local $@;
         $success = _clean_eval($make_sub, \%captures);
         $e = $@;
       }
       unless ($success) {
         die "Eval went very, very wrong:\n\n${make_sub}\n\n$e";
       }
       weaken($QUOTED{$$unquoted} = $quoted);
     }
   }
   $$unquoted;
 }
 
 sub qsub ($) {
   goto &quote_sub;
 }
 
 sub CLONE {
   %QUOTED = map { defined $_ ? (
     $_->[3] && ${$_->[3]} ? (${ $_->[3] } => $_) : (),
     $_->[4] ? ($_->[4] => $_) : (),
   ) : () } values %QUOTED;
   weaken($_) for values %QUOTED;
 }
 
 1;
 __END__
 
### Sys/Syslog.pm ###
 package Sys::Syslog;
 use strict;
 use warnings;
 use warnings::register;
 use Carp;
 use Exporter        qw< import >;
 use File::Basename;
 use POSIX           qw< strftime setlocale LC_TIME >;
 use Socket          qw< :all >;
 require 5.005;
 
 
 {   no strict 'vars';
     $VERSION = '0.33';
 
     %EXPORT_TAGS = (
         standard => [qw(openlog syslog closelog setlogmask)],
         extended => [qw(setlogsock)],
         macros => [
             qw(
                 LOG_ALERT LOG_CRIT LOG_DEBUG LOG_EMERG LOG_ERR 
                 LOG_INFO LOG_NOTICE LOG_WARNING
             ), 
 
             qw(
                 LOG_AUTH LOG_AUTHPRIV LOG_CRON LOG_DAEMON LOG_FTP LOG_KERN
                 LOG_LOCAL0 LOG_LOCAL1 LOG_LOCAL2 LOG_LOCAL3 LOG_LOCAL4
                 LOG_LOCAL5 LOG_LOCAL6 LOG_LOCAL7 LOG_LPR LOG_MAIL LOG_NEWS
                 LOG_SYSLOG LOG_USER LOG_UUCP
             ),
             qw( LOG_INSTALL LOG_LAUNCHD LOG_NETINFO LOG_RAS LOG_REMOTEAUTH ),
             qw( LOG_CONSOLE LOG_NTP LOG_SECURITY ),
             qw( LOG_AUDIT LOG_LFMT ),
 
             qw(
                 LOG_CONS LOG_PID LOG_NDELAY LOG_NOWAIT LOG_ODELAY LOG_PERROR 
             ), 
 
             qw(
                 LOG_FACMASK LOG_NFACILITIES LOG_PRIMASK 
                 LOG_MASK LOG_UPTO
             ), 
         ],
     );
 
     @EXPORT = (
         @{$EXPORT_TAGS{standard}}, 
     );
 
     @EXPORT_OK = (
         @{$EXPORT_TAGS{extended}}, 
         @{$EXPORT_TAGS{macros}}, 
     );
 
     eval {
         require XSLoader;
         XSLoader::load('Sys::Syslog', $VERSION);
         1
     } or do {
         require DynaLoader;
         push @ISA, 'DynaLoader';
         bootstrap Sys::Syslog $VERSION;
     };
 }
 
 
 use vars qw($host);             
 
 sub silent_eval (&);
 
 use vars qw($facility);
 my $connected       = 0;        
 my $syslog_send;                
 my $syslog_path     = undef;    
 my $syslog_xobj     = undef;    
 my $transmit_ok     = 0;        
 my $sock_port       = undef;    
 my $sock_timeout    = 0;        
 my $current_proto   = undef;    
 my $ident           = '';       
 $facility           = '';       
 my $maskpri         = LOG_UPTO(&LOG_DEBUG);     
 
 my %options = (
     ndelay  => 0, 
     noeol   => 0,
     nofatal => 0, 
     nonul   => 0,
     nowait  => 0, 
     perror  => 0, 
     pid     => 0, 
 );
 
 my @connectMethods = qw(native tcp udp unix pipe stream console);
 if ($^O eq "freebsd" or $^O eq "linux") {
     @connectMethods = grep { $_ ne 'udp' } @connectMethods;
 }
 
 EVENTLOG: {
     my $is_Win32 = $^O =~ /Win32/i;
 
     if (can_load("Sys::Syslog::Win32", $is_Win32)) {
         unshift @connectMethods, 'eventlog';
     }
 }
 
 my @defaultMethods = @connectMethods;
 my @fallbackMethods = ();
 
 
 $sock_timeout = 0.001 if $^O =~ /darwin|gnukfreebsd/;
 
 
 if (not defined &warnings::warnif) {
     *warnings::warnif = sub {
         goto &warnings::warn if warnings::enabled(__PACKAGE__)
     }
 }
 
 my $err_sub = $options{nofatal} ? \&warnings::warnif : \&croak;
 
 
 sub AUTOLOAD {
     no strict 'vars';
     my $constname;
     ($constname = $AUTOLOAD) =~ s/.*:://;
     croak "Sys::Syslog::constant() not defined" if $constname eq 'constant';
     my ($error, $val) = constant($constname);
     croak $error if $error;
     no strict 'refs';
     *$AUTOLOAD = sub { $val };
     goto &$AUTOLOAD;
 }
 
 
 sub openlog {
     ($ident, my $logopt, $facility) = @_;
 
     $ident    ||= basename($0) || getlogin() || getpwuid($<) || 'syslog';
     $logopt   ||= '';
     $facility ||= LOG_USER();
 
     for my $opt (split /\b/, $logopt) {
         $options{$opt} = 1 if exists $options{$opt}
     }
 
     $err_sub = delete $options{nofatal} ? \&warnings::warnif : \&croak;
     return 1 unless $options{ndelay};
     connect_log();
 } 
 
 sub closelog {
     disconnect_log() if $connected;
     $options{$_} = 0 for keys %options;
     $facility = $ident = "";
     $connected = 0;
     return 1
 } 
 
 sub setlogmask {
     my $oldmask = $maskpri;
     $maskpri = shift unless $_[0] == 0;
     $oldmask;
 }
 
 
 my %mechanism = (
     console => {
         check   => sub { 1 },
     },
     eventlog => {
         check   => sub { return can_load("Win32::EventLog") },
         err_msg => "no Win32 API available",
     },
     inet => {
         check   => sub { 1 },
     },
     native => {
         check   => sub { 1 },
     },
     pipe => {
         check   => sub {
             ($syslog_path) = grep { defined && length && -p && -w _ }
                                 $syslog_path, &_PATH_LOG, "/dev/log";
             return $syslog_path ? 1 : 0
         },
         err_msg => "path not available",
     },
     stream => {
         check   => sub {
             if (not defined $syslog_path) {
                 my @try = qw(/dev/log /dev/conslog);
                 unshift @try, &_PATH_LOG  if length &_PATH_LOG;
                 ($syslog_path) = grep { -w } @try;
             }
             return defined $syslog_path && -w $syslog_path
         },
         err_msg => "could not find any writable device",
     },
     tcp => {
         check   => sub {
             return 1 if defined $sock_port;
 
             if (getservbyname('syslog', 'tcp') || getservbyname('syslogng', 'tcp')) {
                 $host = $syslog_path;
                 return 1
             }
             else {
                 return
             }
         },
         err_msg => "TCP service unavailable",
     },
     udp => {
         check   => sub {
             return 1 if defined $sock_port;
 
             if (getservbyname('syslog', 'udp')) {
                 $host = $syslog_path;
                 return 1
             }
             else {
                 return
             }
         },
         err_msg => "UDP service unavailable",
     },
     unix => {
         check   => sub {
             my @try = ($syslog_path, &_PATH_LOG);
             ($syslog_path) = grep { defined && length && -w } @try;
             return defined $syslog_path && -w $syslog_path
         },
         err_msg => "path not available",
     },
 );
  
 sub setlogsock {
     my %opt;
 
     croak "setlogsock(): Invalid number of arguments"
         unless @_ >= 1 and @_ <= 3;
 
     if (my $ref = ref $_[0]) {
         if ($ref eq "HASH") {
             %opt = %{ $_[0] };
             croak "setlogsock(): No argument given" unless keys %opt;
         }
         elsif ($ref eq "ARRAY") {
             @opt{qw< type path timeout >} = @_;
         }
         else {
             croak "setlogsock(): Unexpected \L$ref\E reference"
         }
     }
     else {
         @opt{qw< type path timeout >} = @_;
     }
 
     my $diag_invalid_type = "setlogsock(): Invalid type%s; must be one of "
                           . join ", ", map { "'$_'" } sort keys %mechanism;
     croak sprintf $diag_invalid_type, "" unless defined $opt{type};
     my @sock_types = ref $opt{type} eq "ARRAY" ? @{$opt{type}} : ($opt{type});
     my @tmp;
 
     for my $sock_type (@sock_types) {
         carp sprintf $diag_invalid_type, " '$sock_type'" and next
             unless exists $mechanism{$sock_type};
         push @tmp, "tcp", "udp" and next  if $sock_type eq "inet";
         push @tmp, $sock_type;
     }
 
     @sock_types = @tmp;
 
     $syslog_path  = $opt{path}    if defined $opt{path};
     $host         = $opt{host}    if defined $opt{host};
     $sock_timeout = $opt{timeout} if defined $opt{timeout};
     $sock_port    = $opt{port}    if defined $opt{port};
 
     disconnect_log() if $connected;
     $transmit_ok = 0;
     @fallbackMethods = ();
     @connectMethods = ();
     my $found = 0;
 
     for my $sock_type (@sock_types) {
         if ( $mechanism{$sock_type}{check}->() ) {
             push @connectMethods, $sock_type;
             $found = 1;
         }
         else {
             warnings::warnif("setlogsock(): type='$sock_type': "
                            . $mechanism{$sock_type}{err_msg});
         }
     }
 
     @connectMethods = @defaultMethods unless @connectMethods;
 
     return $found;
 }
 
 sub syslog {
     my ($priority, $mask, @args) = @_;
     my ($message, $buf);
     my (@words, $num, $numpri, $numfac, $sum);
     my $failed = undef;
     my $fail_time = undef;
     my $error = $!;
 
     openlog() unless $ident;
 
     local $facility = $facility;    
 
     croak "syslog: expecting argument \$priority" unless defined $priority;
     croak "syslog: expecting argument \$format"   unless defined $mask;
 
     if ($priority =~ /^\d+$/) {
         $numpri = LOG_PRI($priority);
         $numfac = LOG_FAC($priority) << 3;
     }
     elsif ($priority =~ /^\w+/) {
         @words = split /\W+/, $priority, 2;
 
         undef $numpri;
         undef $numfac;
 
         for my $word (@words) {
             next if length $word == 0;
 
             $num = xlate($word);
 
             if ($num < 0) {
                 croak "syslog: invalid level/facility: $word"
             }
             elsif ($num <= LOG_PRIMASK() and $word ne "kern") {
                 croak "syslog: too many levels given: $word"
                     if defined $numpri;
                 $numpri = $num;
             }
             else {
                 croak "syslog: too many facilities given: $word"
                     if defined $numfac;
                 $facility = $word if $word =~ /^[A-Za-z]/;
                 $numfac = $num;
             }
         }
     }
     else {
         croak "syslog: invalid level/facility: $priority"
     }
 
     croak "syslog: level must be given" unless defined $numpri;
 
     return 0 unless LOG_MASK($numpri) & $maskpri;
 
     if (not defined $numfac) {  
 	$facility = 'user' unless $facility;
 	$numfac = xlate($facility);
     }
 
     connect_log() unless $connected;
 
     if ($mask =~ /%m/) {
         $error =~ s/%/%%/g if @args;
         $mask =~ s/(?<!%)((?:%%)*)%m/$1$error/g;
     }
 
     $mask .= "\n" unless $mask =~ /\n$/;
     $message = @args ? sprintf($mask, @args) : $mask;
 
     if ($current_proto eq 'native') {
         $buf = $message;
     }
     elsif ($current_proto eq 'eventlog') {
         $buf = $message;
     }
     else {
         my $whoami = $ident;
         $whoami .= "[$$]" if $options{pid};
 
         $sum = $numpri + $numfac;
         my $oldlocale = setlocale(LC_TIME);
         setlocale(LC_TIME, 'C');
         my $timestamp = strftime "%b %d %H:%M:%S", localtime;
         setlocale(LC_TIME, $oldlocale);
 
         $buf = "<$sum>$timestamp $whoami: $message";
 
         $buf .= "\n" if !$options{noeol} and rindex($buf, "\n") == -1;
 
         $buf .= "\0" if !$options{nonul};
     }
 
     if ($options{perror} and $current_proto ne 'native') {
         my $whoami = $ident;
         $whoami .= "[$$]" if $options{pid};
         print STDERR "$whoami: $message\n";
     }
 
     while (scalar @fallbackMethods || $syslog_send) {
 	if ($failed && (time - $fail_time) > 60) {
 	    @fallbackMethods = ();
 	    disconnect_log();
 	    $transmit_ok = 0; 
 	    connect_log();
         }
 
 	if ($connected && !connection_ok()) {
 	    $failed = $current_proto unless $failed;
 	    $fail_time = time;
 	    disconnect_log();
 	}
 
 	connect_log() unless $connected;
 	$failed = undef if ($current_proto && $failed && $current_proto eq $failed);
 
 	if ($syslog_send) {
             if ($syslog_send->($buf, $numpri, $numfac)) {
 		$transmit_ok++;
 		return 1;
 	    }
 	    disconnect_log();
 	}
     }
     return 0;
 }
 
 sub _syslog_send_console {
     my ($buf) = @_;
 
     if (my $pid = fork) {
 
 	if ($options{nowait}) {
 	    return 1;
 	} else {
 	    if (waitpid($pid, 0) >= 0) {
 	    	return ($? >> 8);
 	    } else {
 		return 1;
 	    }
 	}
     } else {
         if (open(CONS, ">/dev/console")) {
 	    my $ret = print CONS $buf . "\r";  
 	    POSIX::_exit($ret) if defined $pid;
 	    close CONS;
 	}
 
 	POSIX::_exit(0) if defined $pid;
     }
 }
 
 sub _syslog_send_stream {
     my ($buf) = @_;
     return syswrite(SYSLOG, $buf, length($buf));
 }
 
 sub _syslog_send_pipe {
     my ($buf) = @_;
     return print SYSLOG $buf;
 }
 
 sub _syslog_send_socket {
     my ($buf) = @_;
     return syswrite(SYSLOG, $buf, length($buf));
 }
 
 sub _syslog_send_native {
     my ($buf, $numpri, $numfac) = @_;
     syslog_xs($numpri|$numfac, $buf);
     return 1;
 }
 
 
 sub xlate {
     my ($name) = @_;
 
     return $name+0 if $name =~ /^\s*\d+\s*$/;
     $name = uc $name;
     $name = "LOG_$name" unless $name =~ /^LOG_/;
 
     my $value = constant($name);
 
     if (index($value, "not a valid") >= 0) {
         $name = "Sys::Syslog::$name";
         $value = eval { no strict "refs"; &$name };
         $value = $@ unless defined $value;
     }
 
     $value = -1 if index($value, "not a valid") >= 0;
 
     return defined $value ? $value : -1;
 }
 
 
 sub connect_log {
     @fallbackMethods = @connectMethods unless scalar @fallbackMethods;
 
     if ($transmit_ok && $current_proto) {
 	unshift(@fallbackMethods, $current_proto);
     }
 
     $connected = 0;
     my @errs = ();
     my $proto = undef;
 
     while ($proto = shift @fallbackMethods) {
 	no strict 'refs';
 	my $fn = "connect_$proto";
 	$connected = &$fn(\@errs) if defined &$fn;
 	last if $connected;
     }
 
     $transmit_ok = 0;
     if ($connected) {
 	$current_proto = $proto;
         my ($old) = select(SYSLOG); $| = 1; select($old);
     } else {
 	@fallbackMethods = ();
         $err_sub->(join "\n\t- ", "no connection to syslog available", @errs);
         return undef;
     }
 }
 
 sub connect_tcp {
     my ($errs) = @_;
 
     my $proto = getprotobyname('tcp');
     if (!defined $proto) {
 	push @$errs, "getprotobyname failed for tcp";
 	return 0;
     }
 
     my $port = $sock_port || getservbyname('syslog', 'tcp');
     $port = getservbyname('syslogng', 'tcp') unless defined $port;
     if (!defined $port) {
 	push @$errs, "getservbyname failed for syslog/tcp and syslogng/tcp";
 	return 0;
     }
 
     my $addr;
     if (defined $host) {
         $addr = inet_aton($host);
         if (!$addr) {
 	    push @$errs, "can't lookup $host";
 	    return 0;
 	}
     } else {
         $addr = INADDR_LOOPBACK;
     }
     $addr = sockaddr_in($port, $addr);
 
     if (!socket(SYSLOG, AF_INET, SOCK_STREAM, $proto)) {
 	push @$errs, "tcp socket: $!";
 	return 0;
     }
 
     setsockopt(SYSLOG, SOL_SOCKET, SO_KEEPALIVE, 1);
     if (silent_eval { IPPROTO_TCP() }) {
         setsockopt(SYSLOG, IPPROTO_TCP(), TCP_NODELAY(), 1);
     }
     if (!connect(SYSLOG, $addr)) {
 	push @$errs, "tcp connect: $!";
 	return 0;
     }
 
     $syslog_send = \&_syslog_send_socket;
 
     return 1;
 }
 
 sub connect_udp {
     my ($errs) = @_;
 
     my $proto = getprotobyname('udp');
     if (!defined $proto) {
 	push @$errs, "getprotobyname failed for udp";
 	return 0;
     }
 
     my $port = $sock_port || getservbyname('syslog', 'udp');
     if (!defined $port) {
 	push @$errs, "getservbyname failed for syslog/udp";
 	return 0;
     }
 
     my $addr;
     if (defined $host) {
         $addr = inet_aton($host);
         if (!$addr) {
 	    push @$errs, "can't lookup $host";
 	    return 0;
 	}
     } else {
         $addr = INADDR_LOOPBACK;
     }
     $addr = sockaddr_in($port, $addr);
 
     if (!socket(SYSLOG, AF_INET, SOCK_DGRAM, $proto)) {
 	push @$errs, "udp socket: $!";
 	return 0;
     }
     if (!connect(SYSLOG, $addr)) {
 	push @$errs, "udp connect: $!";
 	return 0;
     }
 
     _syslog_send_socket("");
     if (!connection_ok()) {
 	push @$errs, "udp connect: nobody listening";
 	return 0;
     }
 
     $syslog_send = \&_syslog_send_socket;
 
     return 1;
 }
 
 sub connect_stream {
     my ($errs) = @_;
     $syslog_path = '/dev/conslog' unless defined $syslog_path; 
 
     if (!-w $syslog_path) {
 	push @$errs, "stream $syslog_path is not writable";
 	return 0;
     }
 
     require Fcntl;
 
     if (!sysopen(SYSLOG, $syslog_path, Fcntl::O_WRONLY(), 0400)) {
 	push @$errs, "stream can't open $syslog_path: $!";
 	return 0;
     }
 
     $syslog_send = \&_syslog_send_stream;
 
     return 1;
 }
 
 sub connect_pipe {
     my ($errs) = @_;
 
     $syslog_path ||= &_PATH_LOG || "/dev/log";
 
     if (not -w $syslog_path) {
         push @$errs, "$syslog_path is not writable";
         return 0;
     }
 
     if (not open(SYSLOG, ">$syslog_path")) {
         push @$errs, "can't write to $syslog_path: $!";
         return 0;
     }
 
     $syslog_send = \&_syslog_send_pipe;
 
     return 1;
 }
 
 sub connect_unix {
     my ($errs) = @_;
 
     $syslog_path ||= _PATH_LOG() if length _PATH_LOG();
 
     if (not defined $syslog_path) {
         push @$errs, "_PATH_LOG not available in syslog.h and no user-supplied socket path";
 	return 0;
     }
 
     if (not (-S $syslog_path or -c _)) {
         push @$errs, "$syslog_path is not a socket";
 	return 0;
     }
 
     my $addr = sockaddr_un($syslog_path);
     if (!$addr) {
 	push @$errs, "can't locate $syslog_path";
 	return 0;
     }
     if (!socket(SYSLOG, AF_UNIX, SOCK_STREAM, 0)) {
         push @$errs, "unix stream socket: $!";
 	return 0;
     }
 
     if (!connect(SYSLOG, $addr)) {
         if (!socket(SYSLOG, AF_UNIX, SOCK_DGRAM, 0)) {
 	    push @$errs, "unix dgram socket: $!";
 	    return 0;
 	}
         if (!connect(SYSLOG, $addr)) {
 	    push @$errs, "unix dgram connect: $!";
 	    return 0;
 	}
     }
 
     $syslog_send = \&_syslog_send_socket;
 
     return 1;
 }
 
 sub connect_native {
     my ($errs) = @_;
     my $logopt = 0;
 
     for my $opt (keys %options) {
         $logopt += xlate($opt) if $options{$opt}
     }
 
     openlog_xs($ident, $logopt, xlate($facility));
     $syslog_send = \&_syslog_send_native;
 
     return 1;
 }
 
 sub connect_eventlog {
     my ($errs) = @_;
 
     $syslog_xobj = Sys::Syslog::Win32::_install();
     $syslog_send = \&Sys::Syslog::Win32::_syslog_send;
 
     return 1;
 }
 
 sub connect_console {
     my ($errs) = @_;
     if (!-w '/dev/console') {
 	push @$errs, "console is not writable";
 	return 0;
     }
     $syslog_send = \&_syslog_send_console;
     return 1;
 }
 
 sub connection_ok {
     return 1 if defined $current_proto and (
         $current_proto eq 'native' or $current_proto eq 'console'
         or $current_proto eq 'eventlog'
     );
 
     my $rin = '';
     vec($rin, fileno(SYSLOG), 1) = 1;
     my $ret = select $rin, undef, $rin, $sock_timeout;
     return ($ret ? 0 : 1);
 }
 
 sub disconnect_log {
     $connected = 0;
     $syslog_send = undef;
 
     if (defined $current_proto and $current_proto eq 'native') {
         closelog_xs();
         unshift @fallbackMethods, $current_proto;
         $current_proto = undef;
         return 1;
     }
     elsif (defined $current_proto and $current_proto eq 'eventlog') {
         $syslog_xobj->Close();
         unshift @fallbackMethods, $current_proto;
         $current_proto = undef;
         return 1;
     }
 
     return close SYSLOG;
 }
 
 
 sub silent_eval (&) {
     local($SIG{__DIE__}, $SIG{__WARN__}, $@);
     return eval { $_[0]->() }
 }
 
 sub can_load {
     my ($module, $verbose) = @_;
     local($SIG{__DIE__}, $SIG{__WARN__}, $@);
     my $loaded = eval "use $module; 1";
     warn $@ if not $loaded and $verbose;
     return $loaded
 }
 
 
 "Eighth Rule: read the documentation."
 
 __END__
 
 
### Term/ANSIColor.pm ###
 
 
 package Term::ANSIColor;
 
 use 5.006;
 use strict;
 use warnings;
 
 use Carp qw(croak);
 use Exporter ();
 
 
 our (@EXPORT, @EXPORT_OK, %EXPORT_TAGS, @ISA, $VERSION);
 
 our $AUTOLOAD;
 
 BEGIN {
     $VERSION = '4.03';
 
     my @colorlist = qw(
       CLEAR           RESET             BOLD            DARK
       FAINT           ITALIC            UNDERLINE       UNDERSCORE
       BLINK           REVERSE           CONCEALED
 
       BLACK           RED               GREEN           YELLOW
       BLUE            MAGENTA           CYAN            WHITE
       ON_BLACK        ON_RED            ON_GREEN        ON_YELLOW
       ON_BLUE         ON_MAGENTA        ON_CYAN         ON_WHITE
 
       BRIGHT_BLACK    BRIGHT_RED        BRIGHT_GREEN    BRIGHT_YELLOW
       BRIGHT_BLUE     BRIGHT_MAGENTA    BRIGHT_CYAN     BRIGHT_WHITE
       ON_BRIGHT_BLACK ON_BRIGHT_RED     ON_BRIGHT_GREEN ON_BRIGHT_YELLOW
       ON_BRIGHT_BLUE  ON_BRIGHT_MAGENTA ON_BRIGHT_CYAN  ON_BRIGHT_WHITE
     );
 
     my @colorlist256 = (
         (map { ("ANSI$_", "ON_ANSI$_") } 0 .. 15),
         (map { ("GREY$_", "ON_GREY$_") } 0 .. 23),
     );
     for my $r (0 .. 5) {
         for my $g (0 .. 5) {
             push(@colorlist256, map { ("RGB$r$g$_", "ON_RGB$r$g$_") } 0 .. 5);
         }
     }
 
     @ISA         = qw(Exporter);
     @EXPORT      = qw(color colored);
     @EXPORT_OK   = qw(uncolor colorstrip colorvalid coloralias);
     %EXPORT_TAGS = (
         constants    => \@colorlist,
         constants256 => \@colorlist256,
         pushpop      => [@colorlist, qw(PUSHCOLOR POPCOLOR LOCALCOLOR)],
     );
     Exporter::export_ok_tags('pushpop', 'constants256');
 }
 
 
 our $AUTOLOCAL;
 
 our $AUTORESET;
 
 our $EACHLINE;
 
 
 
 our %ATTRIBUTES = (
     'clear'          => 0,
     'reset'          => 0,
     'bold'           => 1,
     'dark'           => 2,
     'faint'          => 2,
     'italic'         => 3,
     'underline'      => 4,
     'underscore'     => 4,
     'blink'          => 5,
     'reverse'        => 7,
     'concealed'      => 8,
 
     'black'          => 30,   'on_black'          => 40,
     'red'            => 31,   'on_red'            => 41,
     'green'          => 32,   'on_green'          => 42,
     'yellow'         => 33,   'on_yellow'         => 43,
     'blue'           => 34,   'on_blue'           => 44,
     'magenta'        => 35,   'on_magenta'        => 45,
     'cyan'           => 36,   'on_cyan'           => 46,
     'white'          => 37,   'on_white'          => 47,
 
     'bright_black'   => 90,   'on_bright_black'   => 100,
     'bright_red'     => 91,   'on_bright_red'     => 101,
     'bright_green'   => 92,   'on_bright_green'   => 102,
     'bright_yellow'  => 93,   'on_bright_yellow'  => 103,
     'bright_blue'    => 94,   'on_bright_blue'    => 104,
     'bright_magenta' => 95,   'on_bright_magenta' => 105,
     'bright_cyan'    => 96,   'on_bright_cyan'    => 106,
     'bright_white'   => 97,   'on_bright_white'   => 107,
 );
 
 
 for my $code (0 .. 15) {
     $ATTRIBUTES{"ansi$code"}    = "38;5;$code";
     $ATTRIBUTES{"on_ansi$code"} = "48;5;$code";
 }
 
 for my $r (0 .. 5) {
     for my $g (0 .. 5) {
         for my $b (0 .. 5) {
             my $code = 16 + (6 * 6 * $r) + (6 * $g) + $b;
             $ATTRIBUTES{"rgb$r$g$b"}    = "38;5;$code";
             $ATTRIBUTES{"on_rgb$r$g$b"} = "48;5;$code";
         }
     }
 }
 
 for my $n (0 .. 23) {
     my $code = $n + 232;
     $ATTRIBUTES{"grey$n"}    = "38;5;$code";
     $ATTRIBUTES{"on_grey$n"} = "48;5;$code";
 }
 
 our %ATTRIBUTES_R;
 for my $attr (reverse sort keys %ATTRIBUTES) {
     $ATTRIBUTES_R{ $ATTRIBUTES{$attr} } = $attr;
 }
 
 our %ALIASES;
 if (exists $ENV{ANSI_COLORS_ALIASES}) {
     my $spec = $ENV{ANSI_COLORS_ALIASES};
     $spec =~ s{\s+}{}xmsg;
 
     for my $definition (split m{,}xms, $spec) {
         my ($new, $old) = split m{=}xms, $definition, 2;
         if (!$new || !$old) {
             warn qq{Bad color mapping "$definition"};
         } else {
             my $result = eval { coloralias($new, $old) };
             if (!$result) {
                 my $error = $@;
                 $error =~ s{ [ ] at [ ] .* }{}xms;
                 warn qq{$error in "$definition"};
             }
         }
     }
 }
 
 our @COLORSTACK;
 
 
 sub AUTOLOAD {
     my ($sub, $attr) = $AUTOLOAD =~ m{ \A ([\w:]*::([[:upper:]\d_]+)) \z }xms;
 
     if (!($attr && defined($ATTRIBUTES{ lc $attr }))) {
         croak("undefined subroutine &$AUTOLOAD called");
     }
 
     if ($ENV{ANSI_COLORS_DISABLED}) {
         return join(q{}, @_);
     }
 
     $AUTOLOAD = $sub;
 
     my $escape = "\e[" . $ATTRIBUTES{ lc $attr } . 'm';
 
     my $eval_err = $@;
 
     my $eval_result = eval qq{
         sub $AUTOLOAD {
             if (\$ENV{ANSI_COLORS_DISABLED}) {
                 return join(q{}, \@_);
             } elsif (\$AUTOLOCAL && \@_) {
                 return PUSHCOLOR('$escape') . join(q{}, \@_) . POPCOLOR;
             } elsif (\$AUTORESET && \@_) {
                 return '$escape' . join(q{}, \@_) . "\e[0m";
             } else {
                 return '$escape' . join(q{}, \@_);
             }
         }
         1;
     };
 
     if (!$eval_result) {
         die "failed to generate constant $attr: $@";
     }
 
     $@ = $eval_err;
 
     goto &$AUTOLOAD;
 }
 
 sub PUSHCOLOR {
     my (@text) = @_;
     my $text = join(q{}, @text);
 
     my ($color) = $text =~ m{ \A ( (?:\e\[ [\d;]+ m)+ ) }xms;
 
     if (@COLORSTACK) {
         $color = $COLORSTACK[-1] . $color;
     }
 
     push(@COLORSTACK, $color);
     return $text;
 }
 
 sub POPCOLOR {
     my (@text) = @_;
     pop(@COLORSTACK);
     if (@COLORSTACK) {
         return $COLORSTACK[-1] . join(q{}, @text);
     } else {
         return RESET(@text);
     }
 }
 
 sub LOCALCOLOR {
     my (@text) = @_;
     return PUSHCOLOR(join(q{}, @text)) . POPCOLOR();
 }
 
 
 sub color {
     my (@codes) = @_;
     @codes = map { split } @codes;
 
     if ($ENV{ANSI_COLORS_DISABLED}) {
         return q{};
     }
 
     my $attribute = q{};
     for my $code (@codes) {
         $code = lc($code);
         if (defined($ATTRIBUTES{$code})) {
             $attribute .= $ATTRIBUTES{$code} . q{;};
         } elsif (defined($ALIASES{$code})) {
             $attribute .= $ALIASES{$code} . q{;};
         } else {
             croak("Invalid attribute name $code");
         }
     }
 
     chop($attribute);
 
     return ($attribute ne q{}) ? "\e[${attribute}m" : undef;
 }
 
 sub uncolor {
     my (@escapes) = @_;
     my (@nums, @result);
 
     for my $escape (@escapes) {
         $escape =~ s{ \A \e\[ }{}xms;
         $escape =~ s{ m \z }   {}xms;
         my ($attrs) = $escape =~ m{ \A ((?:\d+;)* \d*) \z }xms;
         if (!defined($attrs)) {
             croak("Bad escape sequence $escape");
         }
 
         push(@nums, $attrs =~ m{ ( 0*[34]8;0*5;\d+ | \d+ ) (?: ; | \z ) }xmsg);
     }
 
     for my $num (@nums) {
         $num =~ s{ ( \A | ; ) 0+ (\d) }{$1$2}xmsg;
         my $name = $ATTRIBUTES_R{$num};
         if (!defined($name)) {
             croak("No name for escape sequence $num");
         }
         push(@result, $name);
     }
 
     return @result;
 }
 
 sub colored {
     my ($first, @rest) = @_;
     my ($string, @codes);
     if (ref($first) && ref($first) eq 'ARRAY') {
         @codes = @{$first};
         $string = join(q{}, @rest);
     } else {
         $string = $first;
         @codes  = @rest;
     }
 
     if ($ENV{ANSI_COLORS_DISABLED}) {
         return $string;
     }
 
     my $attr = color(@codes);
 
     if (defined($EACHLINE)) {
         my @text = map { ($_ ne $EACHLINE) ? $attr . $_ . "\e[0m" : $_ }
           grep { length($_) > 0 }
           split(m{ (\Q$EACHLINE\E) }xms, $string);
         return join(q{}, @text);
     } else {
         return $attr . $string . "\e[0m";
     }
 }
 
 sub coloralias {
     my ($alias, $color) = @_;
     if (!defined($color)) {
         if (!exists $ALIASES{$alias}) {
             return;
         } else {
             return $ATTRIBUTES_R{ $ALIASES{$alias} };
         }
     }
     if ($alias !~ m{ \A [\w._-]+ \z }xms) {
         croak(qq{Invalid alias name "$alias"});
     } elsif ($ATTRIBUTES{$alias}) {
         croak(qq{Cannot alias standard color "$alias"});
     } elsif (!exists $ATTRIBUTES{$color}) {
         croak(qq{Invalid attribute name "$color"});
     }
     $ALIASES{$alias} = $ATTRIBUTES{$color};
     return $color;
 }
 
 sub colorstrip {
     my (@string) = @_;
     for my $string (@string) {
         $string =~ s{ \e\[ [\d;]* m }{}xmsg;
     }
     return wantarray ? @string : join(q{}, @string);
 }
 
 sub colorvalid {
     my (@codes) = @_;
     @codes = map { split(q{ }, lc($_)) } @codes;
     for my $code (@codes) {
         if (!defined($ATTRIBUTES{$code}) && !defined($ALIASES{$code})) {
             return;
         }
     }
     return 1;
 }
 
 
 1;
 __END__
 
### Term/App/Role/Attrs.pm ###
 package Term::App::Role::Attrs;
 
 our $DATE = '2014-12-10'; 
 our $VERSION = '0.01'; 
 
 use 5.010001;
 use Moo::Role;
 
 my $dt_cache;
 sub detect_terminal {
     my $self = shift;
 
     if (!$dt_cache) {
         require Term::Detect::Software;
         $dt_cache = Term::Detect::Software::detect_terminal_cached();
     }
     $dt_cache;
 }
 
 my $termw_cache;
 my $termh_cache;
 sub _term_size {
     my $self = shift;
 
     if (defined $termw_cache) {
         return ($termw_cache, $termh_cache);
     }
 
     ($termw_cache, $termh_cache) = (0, 0);
     if (eval { require Term::Size; 1 }) {
         ($termw_cache, $termh_cache) = Term::Size::chars();
     }
     ($termw_cache, $termh_cache);
 }
 
 sub __parse_color_depth {
     my $val = shift;
     if ($val =~ /\A\d+\z/) {
         return $val;
     } elsif ($val =~ /\A(\d+)[ _-]?(?:bit|b)\z/) {
         return 2**$val;
     } else {
         return undef;
     }
 }
 
 has interactive => (
     is      => 'rw',
     lazy    => 1,
     default => sub {
         my $self = shift;
         if (defined $ENV{INTERACTIVE}) {
             $self->{_term_attrs_debug_info}{interactive_from} =
                 'INTERACTIVE env';
             return $ENV{INTERACTIVE};
         } else {
             $self->{_term_attrs_debug_info}{interactive_from} =
                 '-t STDOUT';
             return (-t STDOUT);
         }
     },
 );
 
 has use_color => (
     is      => 'rw',
     lazy    => 1,
     default => sub {
         my $self = shift;
         if (defined $ENV{COLOR}) {
             $self->{_term_attrs_debug_info}{use_color_from} =
                 'COLOR env';
             return $ENV{COLOR};
         } elsif (defined $ENV{COLOR_DEPTH}) {
             $self->{_term_attrs_debug_info}{use_color_from} =
                 'COLOR_DEPTH env';
             my $val = __parse_color_depth($ENV{COLOR_DEPTH}) //
                 $ENV{COLOR_DEPTH};
             return $val ? 1:0;
         } else {
             $self->{_term_attrs_debug_info}{use_color_from} =
                 'interactive + color_deth';
             return $self->interactive && $self->color_depth > 0;
         }
     },
     trigger => sub {
         my ($self, $val) = @_;
         return if !defined($val) || $val =~ /\A(|1|0)\z/;
         my $pval = __parse_color_depth($val);
         $self->{color_depth} = $pval if defined $pval;
     },
 );
 
 has color_depth => (
     is      => 'rw',
     lazy    => 1,
     default => sub {
         my $self = shift;
         my $pval;
         if (defined($ENV{COLOR_DEPTH}) &&
                 defined($pval = __parse_color_depth($ENV{COLOR_DEPTH}))) {
             $self->{_term_attrs_debug_info}{color_depth_from} =
                 'COLOR_DEPTH env';
             return $pval;
         } elsif (defined($ENV{COLOR}) && $ENV{COLOR} !~ /^(|0|1)$/ &&
                      defined($pval = __parse_color_depth($ENV{COLOR}))) {
                 $self->{_term_attrs_debug_info}{color_depth_from} =
                     'COLOR env';
             return $pval;
         } elsif (defined(my $cd = $self->detect_terminal->{color_depth})) {
             $self->{_term_attrs_debug_info}{color_depth_from} =
                 'detect_terminal';
             return $cd;
         } else {
             $self->{_term_attrs_debug_info}{color_depth_from} =
                 'hardcoded default';
             return 16;
         }
     },
     trigger => sub {
         my ($self, $val) = @_;
         if (defined(my $pval = __parse_color_depth($val))) {
             $self->{color_depth} = $val = $pval;
         }
         if ($val) {
             $self->{use_color} = 1;
         } else {
             $self->{use_color} = 0;
         }
     },
 );
 
 has use_box_chars => (
     is      => 'rw',
     lazy    => 1,
     default => sub {
         my $self = shift;
         if (defined $ENV{BOX_CHARS}) {
             $self->{_term_attrs_debug_info}{use_box_chars_from} =
                 'BOX_CHARS env';
             return $ENV{BOX_CHARS};
         } elsif (!$self->interactive) {
             $self->{_term_attrs_debug_info}{use_box_chars_from} =
                 '(not) interactive';
             return 0;
         } elsif (defined(my $bc = $self->detect_terminal->{box_chars})) {
             $self->{_term_attrs_debug_info}{use_box_chars_from} =
                 'detect_terminal';
             return $bc;
         } else {
             $self->{_term_attrs_debug_info}{use_box_chars_from} =
                 'hardcoded default';
             return 0;
         }
     },
 );
 
 has use_utf8 => (
     is      => 'rw',
     lazy    => 1,
     default => sub {
         my $self = shift;
         if (defined $ENV{UTF8}) {
             $self->{_term_attrs_debug_info}{use_utf8_from} =
                 'UTF8 env';
             return $ENV{UTF8};
         } elsif (defined(my $termuni = $self->detect_terminal->{unicode})) {
             $self->{_term_attrs_debug_info}{use_utf8_from} =
                 'detect_terminal + LANG/LANGUAGE env must include "utf8"';
             return $termuni &&
                 (($ENV{LANG} || $ENV{LANGUAGE} || "") =~ /utf-?8/i ? 1:0);
         } else {
             $self->{_term_attrs_debug_info}{use_utf8_from} =
                 'hardcoded default';
             return 0;
         }
     },
 );
 
 has _term_attrs_debug_info => (is => 'rw', default=>sub{ {} });
 
 has term_width => (
     is      => 'rw',
     lazy    => 1,
     default => sub {
         my $self = shift;
         if ($ENV{COLUMNS}) {
             $self->{_term_attrs_debug_info}{term_width_from} = 'COLUMNS env';
             return $ENV{COLUMNS};
         }
         my ($termw, undef) = $self->_term_size;
         if ($termw) {
             $self->{_term_attrs_debug_info}{term_width_from} = 'term_size';
         } else {
             $self->{_term_attrs_debug_info}{term_width_from} =
                 'hardcoded default';
             $termw = $^O =~ /Win/ ? 79 : 80;
         }
         $termw;
     },
 );
 
 has term_height => (
     is      => 'rw',
     lazy    => 1,
     default => sub {
         my $self = shift;
         if ($ENV{LINES}) {
             $self->{_term_attrs_debug_info}{term_height_from} = 'LINES env';
             return $ENV{LINES};
         }
         my (undef, $termh) = $self->_term_size;
         if ($termh) {
             $self->{_term_attrs_debug_info}{term_height_from} = 'term_size';
         } else {
             $self->{_term_attrs_debug_info}{term_height_from} = 'default';
             $termh = 25;
         }
         $termh;
     },
 );
 
 1;
 
 __END__
 
### Term/App/Roles.pm ###
 package Term::App::Roles;
 
 our $DATE = '2014-12-10'; 
 our $VERSION = '0.01'; 
 
 1;
 
 __END__
 
### Term/Detect/Software.pm ###
 package Term::Detect::Software;
 
 our $DATE = '2015-01-03'; 
 our $VERSION = '0.21'; 
 
 use 5.010001;
 use strict;
 use warnings;
 use experimental 'smartmatch';
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(detect_terminal detect_terminal_cached);
 
 my $dt_cache;
 sub detect_terminal_cached {
     if (!$dt_cache) {
         $dt_cache = detect_terminal(@_);
     }
     $dt_cache;
 }
 
 sub detect_terminal {
     my @dbg;
     my $info = {_debug_info=>\@dbg};
 
   DETECT:
     {
         unless (defined $ENV{TERM}) {
             push @dbg, "skip: TERM env undefined";
             $info->{emulator_engine}   = '';
             $info->{emulator_software} = '';
             last DETECT;
         }
 
         if ($ENV{KONSOLE_DBUS_SERVICE} || $ENV{KONSOLE_DBUS_SESSION}) {
             push @dbg, "detect: konsole via KONSOLE_DBUS_{SERVICE,SESSION} env";
             $info->{emulator_engine} = 'konsole';
             $info->{color_depth}     = 2**24;
             $info->{default_bgcolor} = '000000';
             $info->{unicode}         = 1;
             $info->{box_chars}       = 1;
             last DETECT;
         }
 
         if ($ENV{XTERM_VERSION}) {
             push @dbg, "detect: xterm via XTERM_VERSION env";
             $info->{emulator_engine} = 'xterm';
             $info->{color_depth}     = 256;
             $info->{default_bgcolor} = 'ffffff';
             $info->{unicode}         = 0;
             $info->{box_chars}       = 1;
             last DETECT;
         }
 
         if ($ENV{TERM} eq 'xterm' && ($ENV{OSTYPE} // '') eq 'cygwin') {
             push @dbg, "detect: xterm via TERM env (cygwin)";
             $info->{emulator_engine} = 'cygwin';
             $info->{color_depth}     = 16;
             $info->{default_bgcolor} = '000000';
             $info->{unicode}         = 0; 
             $info->{box_chars}       = 1;
             last DETECT;
         }
 
         if ($ENV{TERM} eq 'linux') {
             push @dbg, "detect: linux via TERM env";
             $info->{emulator_engine} = 'linux';
             $info->{color_depth}     = 16;
             $info->{default_bgcolor} = '000000';
             $info->{unicode}         = 0;
             $info->{box_chars}       = 0;
             last DETECT;
         }
 
         my $gnome_terminal_terms = [qw/gnome-terminal guake xfce4-terminal
                                        mlterm lxterminal/];
 
         my $set_gnome_terminal_term = sub {
             $info->{emulator_software} = $_[0];
             $info->{emulator_engine}   = 'gnome-terminal';
 
             $info->{color_depth}       = $_[0] =~ /xfce4/ ? 16 : 256;
 
             $info->{unicode}           = 1;
             if ($_[0] ~~ [qw/mlterm/]) {
                 $info->{default_bgcolor} = 'ffffff';
             } else {
                 $info->{default_bgcolor} = '000000';
             }
             $info->{box_chars} = 1;
         };
 
         if (($ENV{COLORTERM} // '') ~~ $gnome_terminal_terms) {
             push @dbg, "detect: gnome-terminal via COLORTERM";
             $set_gnome_terminal_term->($ENV{COLORTERM});
             last DETECT;
         }
 
         if ($ENV{TERM} eq 'dumb' && $ENV{windir}) {
             push @dbg, "detect: windows via TERM & windir env";
             $info->{emulator_software} = 'windows';
             $info->{emulator_engine}   = 'windows';
             $info->{color_depth}       = 16;
             $info->{unicode}           = 0;
             $info->{default_bgcolor}   = '000000';
             $info->{box_chars}         = 0;
             last DETECT;
         }
 
         if ($ENV{TERM} eq 'dumb') {
             push @dbg, "detect: dumb via TERM env";
             $info->{emulator_software} = 'dumb';
             $info->{emulator_engine}   = 'dumb';
             $info->{color_depth}       = 0;
             $info->{default_bgcolor}   = '000000';
             $info->{box_chars}         = 0;
             last DETECT;
         }
 
         {
             last if $^O =~ /Win/;
 
             require Proc::Find::Parents;
             my $ppids = Proc::Find::Parents::get_parent_processes();
             unless (defined $ppids) {
                 push @dbg, "skip: get_parent_processes returns undef";
                 last;
             }
 
             my $proc = @$ppids >= 1 ? $ppids->[1]{name} : '';
             if ($proc ~~ $gnome_terminal_terms) {
                 push @dbg, "detect: gnome-terminal via procname ($proc)";
                 $set_gnome_terminal_term->($proc);
                 last DETECT;
             } elsif ($proc ~~ [qw/rxvt mrxvt/]) {
                 push @dbg, "detect: rxvt via procname ($proc)";
                 $info->{emulator_software} = $proc;
                 $info->{emulator_engine}   = 'rxvt';
                 $info->{color_depth}       = 16;
                 $info->{unicode}           = 0;
                 $info->{default_bgcolor}   = 'd6d2d0';
                 $info->{box_chars}         = 1;
                 last DETECT;
             } elsif ($proc ~~ [qw/pterm/]) {
                 push @dbg, "detect: pterm via procname ($proc)";
                 $info->{emulator_software} = $proc;
                 $info->{emulator_engine}   = 'putty';
                 $info->{color_depth}       = 256;
                 $info->{unicode}           = 0;
                 $info->{default_bgcolor}   = '000000';
                 last DETECT;
             } elsif ($proc ~~ [qw/xvt/]) {
                 push @dbg, "detect: xvt via procname ($proc)";
                 $info->{emulator_software} = $proc;
                 $info->{emulator_engine}   = 'xvt';
                 $info->{color_depth}       = 0; 
                 $info->{unicode}           = 0;
                 $info->{default_bgcolor}   = 'd6d2d0';
                 last DETECT;
             }
         }
 
         {
             unless (exists $info->{color_depth}) {
                 if ($ENV{TERM} =~ /256color/) {
                     push @dbg, "detect color_depth: 256 via TERM env";
                     $info->{color_depth} = 256;
                 } else {
                     require File::Which;
                     if (File::Which::which("tput")) {
                         my $res = `tput colors` + 0;
                         push @dbg, "detect color_depth: $res via tput";
                         $info->{color_depth} = $res;
                     }
                 }
             }
 
             $info->{emulator_software} //= '(generic)';
             $info->{emulator_engine} //= '(generic)';
             $info->{unicode} //= 0;
             $info->{color_depth} //= 0;
             $info->{box_chars} //= 0;
             $info->{default_bgcolor} //= '000000';
         }
 
     } 
 
 
     if ($ENV{INSIDE_EMACS}) {
         $info->{inside_emacs} = 1;
         $info->{box_chars} = 0;
     }
 
     $info;
 }
 
 1;
 
 __END__
 
### Test/Config/IOD/Common.pm ###
 package Test::Config::IOD::Common;
 
 our $DATE = '2015-09-08'; 
 our $VERSION = '0.19'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Module::Load;
 use Test::More 0.98;
 
 our $CLASS = "Config::IOD::Reader";
 
 sub test_common_iod {
 
     load $CLASS;
 
     subtest "opt: default_section" => sub {
         test_read_iod(
             args  => {default_section=>'bawaan'},
             input => <<'_',
 a=1
 _
             result => {bawaan=>{a=>1}},
         );
     };
 
     subtest "opt: allow_directives" => sub {
         test_read_iod(
             args  => {allow_directives=>['merge']},
             input => <<'_',
 ;!noop
 _
             dies  => 1,
         );
         test_read_iod(
             args  => {allow_directives=>['noop']},
             input => <<'_',
 ;!noop
 _
             result => {},
         );
     };
 
     subtest "opt: disallow_directives" => sub {
         test_read_iod(
             args  => {disallow_directives=>['noop']},
             input => <<'_',
 ;!noop
 _
             dies  => 1,
         );
         test_read_iod(
             args  => {disallow_directives=>['merge']},
             input => <<'_',
 ;!noop
 _
             result => {},
         );
     };
 
     subtest "opt: allow_directives + disallow_directives" => sub {
         test_read_iod(
             args  => {
                 allow_directives    => ['noop'],
                 disallow_directives => ['noop'],
             },
             input => <<'_',
 ;!noop
 _
             dies  => 1,
         );
     };
 
     subtest "opt: enable_quoting=0" => sub {
         test_read_iod(
             args  => {enable_quoting=>0},
             input => <<'_',
 name="1\n2"
 _
             result => {GLOBAL=>{name=>'"1\\n2"'}},
         );
     };
 
     subtest "opt: enable_bracket=0" => sub {
         test_read_iod(
             args  => {enable_bracket=>0},
             input => <<'_',
 name=[1,2,3]
 _
             result => {GLOBAL=>{name=>'[1,2,3]'}},
         );
     };
 
     subtest "opt: enable_brace=0" => sub {
         test_read_iod(
             args  => {enable_brace=>0},
             input => <<'_',
 name={"a":1}
 _
             result => {GLOBAL=>{name=>'{"a":1}'}},
         );
     };
 
     subtest "opt: enable_encoding=0" => sub {
         test_read_iod(
             args  => {enable_encoding=>0},
             input => <<'_',
 name=!hex 5e5e
 _
             result => {GLOBAL=>{name=>'!hex 5e5e'}},
         );
     };
 
     subtest "opt: allow_encodings" => sub {
         test_read_iod(
             args  => {allow_encodings=>['hex']},
             input => <<'_',
 name=!json "1\n2"
 _
             dies => 1,
         );
         test_read_iod(
             args  => {allow_encodings=>['json']},
             input => <<'_',
 name=!json "1\n2"
 name2=!j "3\n4"
 _
             result => {GLOBAL=>{name=>"1\n2", name2=>"3\n4"}},
         );
     };
 
     subtest "opt: disallow_encodings" => sub {
         test_read_iod(
             args  => {disallow_encodings=>['json']},
             input => <<'_',
 name=!json "1\n2"
 _
             dies => 1,
         );
         test_read_iod(
             args  => {disallow_encodings=>['json']},
             input => <<'_',
 name=!j "1\n2"
 _
             dies => 1,
         );
         test_read_iod(
             args  => {disallow_encodings=>['hex']},
             input => <<'_',
 name=!json "1\n2"
 _
             result => {GLOBAL=>{name=>"1\n2"}},
         );
     };
 
     subtest "opt: allow_encodings + disallow_encodings" => sub {
         test_read_iod(
             args  => {
                 allow_encodings   =>['json'],
                 disallow_encodings=>['json'],
             },
             input => <<'_',
 name=!json "1\n2"
 _
             dies => 1,
         );
     };
 
     subtest "opt: allow_bang_only=0" => sub {
         test_read_iod(
             args  => {allow_bang_only=>0},
             input => <<'_',
 a=1
 !noop
 _
             dies => 1,
         );
     };
 
     subtest "opt: allow_duplicate_key=0" => sub {
         test_read_iod(
             args  => {allow_duplicate_key=>0},
             input => <<'_',
 a=1
 a=2
 _
             dies => 1,
         );
     };
 
     subtest "opt: ignore_unknown_directive=1" => sub {
         test_read_iod(
             args  => {ignore_unknown_directive=>1},
             input => <<'_',
 ;!foo bar
 _
             result => {},
         );
     };
 
     subtest "expr" => sub {
         test_read_iod(
             name  => "must be enabled first",
             args  => {},
             input => <<'_',
 a=!e 1+1
 _
             dies => 1,
         );
         test_read_iod(
             name  => "must be valid",
             args  => {enable_expr=>1},
             input => <<'_',
 a=!e 1+
 _
             dies => 1,
         );
         test_read_iod(
             args  => {enable_expr=>1},
             input => <<'_',
 a=!e 1+1
 [sect]
 b=!e val("GLOBAL.a")*3
 c=!e val("b") x 3
 _
             result => {GLOBAL=>{a=>2}, sect=>{b=>6, c=>666}},
         );
     };
 }
 
 sub test_read_iod {
     my %args = @_;
 
     my $parser_args = $args{args};
     my $test_name = $args{name} //
         "{". join(", ",
                   (map {"$_=$parser_args->{$_}"}
                        sort keys %$parser_args),
               ) . "}";
     subtest $test_name => sub {
 
         my $parser = $CLASS->new(%$parser_args);
 
         my $res;
         eval {
             if ($CLASS eq 'Config::IOD') {
                 $res = $parser->read_string($args{input})->dump;
             } else {
                 $res = $parser->read_string($args{input});
             }
         };
         my $err = $@;
         if ($args{dies}) {
             ok($err, "dies") or diag explain $res;
             return;
         } else {
             ok(!$err, "doesn't die")
                 or do { diag explain "err=$err"; return };
             is_deeply($res, $args{result}, 'result')
                 or diag explain $res;
         }
     };
 }
 
 1;
 
 __END__
 
### Test/Data/Sah.pm ###
 package Test::Data::Sah;
 
 our $DATE = '2015-10-18'; 
 our $VERSION = '0.74'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Data::Dump qw(dump);
 use Data::Sah qw(gen_validator);
 use Test::More 0.98;
 
 use Exporter qw(import);
 our @EXPORT_OK = qw(test_sah_cases);
 
 sub test_sah_cases {
     my $tests = shift;
     my $opts  = shift // {};
 
     my $sah = Data::Sah->new;
     my $plc = $sah->get_compiler('perl');
 
     my $gvopts = $opts->{gen_validator_opts} // {};
     my $rt = $gvopts->{return_type} // 'bool';
 
     for my $test (@$tests) {
         my $v = gen_validator($test->{schema}, $gvopts);
         my $res = $v->($test->{input});
         my $name = $test->{name} //
             "data " . dump($test->{input}) . " should".
                 ($test->{valid} ? " pass" : " not pass"). " schema " .
                     dump($test->{schema});
         my $testres;
         if ($test->{valid}) {
             if ($rt eq 'bool') {
                 $testres = ok($res, $name);
             } elsif ($rt eq 'str') {
                 $testres = is($res, "", $name) or diag explain $res;
             } elsif ($rt eq 'full') {
                 $testres = is(~~keys(%{$res->{errors}}), 0, $name) or diag explain $res;
             }
         } else {
             if ($rt eq 'bool') {
                 $testres = ok(!$res, $name);
             } elsif ($rt eq 'str') {
                 $testres = isnt($res, "", $name) or diag explain $res;
             } elsif ($rt eq 'full') {
                 $testres = isnt(~~keys(%{$res->{errors}}), 0, $name) or diag explain $res;
             }
         }
         next if $testres;
 
         my $cd = $plc->compile(schema => $test->{schema});
         diag "schema compilation result:\n----begin generated code----\n",
             explain($cd->{result}), "\n----end generated code----\n",
                 "that code should return ", ($test->{valid} ? "true":"false"),
                     " when fed \$data=", dump($test->{input}),
                         " but instead returns ", dump($res);
 
         my $vfull = gen_validator($test->{schema}, {return_type=>"full"});
         diag "\nvalidator result (full):\n----begin result----\n",
             explain($vfull->($test->{input})), "----end result----";
     }
 }
 
 1;
 
 __END__
 
### Test/Perinci/Sub/Wrapper.pm ###
 package Test::Perinci::Sub::Wrapper;
 
 our $DATE = '2015-09-04'; 
 our $VERSION = '0.79'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Function::Fallback::CoreOrPP qw(clone);
 use Perinci::Sub::Wrapper qw(wrap_sub);
 use Test::More 0.96;
 
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(test_wrap);
 
 sub test_wrap {
     my %test_args = @_;
     $test_args{wrap_args} or die "BUG: wrap_args not defined";
     my $test_name = $test_args{name} or die "BUG: test_name not defined";
 
     for my $wrapper_type (qw/dynamic embed/) {
         next if $wrapper_type eq 'dynamic' && $test_args{skip_dynamic};
         next if $wrapper_type eq 'embed'   && $test_args{skip_embed};
         subtest "$test_name ($wrapper_type)" => sub {
 
             if ($test_args{pretest}) {
                 $test_args{pretest}->();
             }
 
             my $wrap_args = clone($test_args{wrap_args});
             die "BUG: embed must not be specified in wrap_args, test_wrap() ".
                 "will always test dynamic (embed=0) *and* embed mode"
                     if exists $wrap_args->{embed};
             if ($wrapper_type eq 'embed') {
                 $wrap_args->{embed} = 1;
             } else {
                 $wrap_args->{embed} = 0;
             }
 
             my $wrap_res;
             eval { $wrap_res = wrap_sub(%$wrap_args) };
             my $wrap_eval_err = $@;
             if ($test_args{wrap_dies}) {
                 ok($wrap_eval_err, "wrap dies");
                 return;
             } else {
                 ok(!$wrap_eval_err, "wrap doesn't die") or do {
                     diag $wrap_eval_err;
                     return;
                 };
             }
 
             if (defined $test_args{wrap_status}) {
                 is(ref($wrap_res), 'ARRAY', 'wrap res is array');
                 is($wrap_res->[0], $test_args{wrap_status},
                    "wrap status is $test_args{wrap_status}")
                     or diag "wrap res: ", explain($wrap_res);
             }
 
             return unless $wrap_res->[0] == 200;
 
             my $sub;
             if ($wrapper_type eq 'embed') {
                 my $src = $wrap_res->[2]{source};
                 my $meta = $wrap_res->[2]{meta};
                 my $args_as = $meta->{args_as};
                 my $orig_args_as = $wrap_args->{meta}{args_as} // 'hash';
                 my $sub_name = $wrap_res->[2]{sub_name};
                 my $eval_src = join(
                     "\n",
                     $src->{presub1},
                     $src->{presub2},
                     'sub {',
                     '    my %args;',
                     ('    my @args;') x !!($orig_args_as eq 'array' || $args_as eq 'array'),
                     ('    my $args;') x !!($orig_args_as =~ /ref/ || $args_as =~ /ref/),
                     '    '.
                         ($args_as eq 'hash' ? '%args = @_;' :
                              $args_as eq 'hashref' ? '$args = $_[0] // {}; %args = %$args;' :
                                  $args_as eq 'array' ? '@args = @_;' :
                                      '$args = $_[0] // [];'),
                     $src->{preamble},
                     ($src->{postamble} ? '    $_w_res = do {' : ''),
                     $sub_name. ($sub_name =~ /\A\$/ ? '->':'').'('.
                         ($orig_args_as eq 'hash' ? '%args' :
                              $orig_args_as eq 'hashref' ? '$args' :
                                  $orig_args_as eq 'array' ? '@args' :
                                      '$args').');',
                     ($src->{postamble} ? '}; # do' : ''),
                     $src->{postamble},
                     '}; # sub',
                 );
                 $sub = eval $eval_src;
                 my $eval_err = $@;
                 ok(!$eval_err, "embed code compiles ok") or do {
                     diag "eval err: ", $eval_err;
                     diag "eval source: ", $eval_src;
                     return;
                 };
                 diag "eval source: ", $eval_src
                     if $ENV{LOG_PERINCI_WRAPPER_CODE};
             } else {
 
                 for my $line (split /^/, $wrap_res->[2]{source}) {
                     if ($line =~ /(.*?)\s+#\s+(.*)/) {
                         my ($before, $after) = ($1, $2);
                         next unless $before =~ /\S/;
                         ok 0; diag "Source code contains comment line after some code '$line' (if you do this, you must use ## instead of # to help ease removing comment lines (e.g. in Dist::Zilla::Plugin::Rinci::Wrap))";
                     }
                 }
 
                 $sub = $wrap_res->[2]{sub};
             }
 
             my $call_argsr = $test_args{call_argsr};
             my $call_res;
             if ($call_argsr) {
                 eval { $call_res = $sub->(@$call_argsr) };
                 my $call_eval_err = $@;
                 if ($test_args{call_dies}) {
                     ok($call_eval_err, "call dies");
                     if ($test_args{call_die_message}) {
                         like($call_eval_err, $test_args{call_die_message},
                              "call die message");
                     }
                     return;
                 } else {
                     ok(!$call_eval_err, "call doesn't die")
                         or diag $call_eval_err;
                 }
 
                 if (defined $test_args{call_status}) {
                     is(ref($call_res), 'ARRAY', 'call res is array')
                         or diag "call res = ", explain($call_res);
                     is($call_res->[0], $test_args{call_status},
                        "call status is $test_args{call_status}")
                         or diag "call res = ", explain($call_res);
                 }
 
                 if (exists $test_args{call_res}) {
                     is_deeply($call_res, $test_args{call_res},
                               "call res")
                         or diag explain $call_res;
                 }
 
                 if (exists $test_args{call_actual_res}) {
                     is_deeply($call_res->[2], $test_args{call_actual_res},
                               "call actual res")
                         or diag explain $call_res->[2];
                 }
 
                 if (exists $test_args{call_actual_res_re}) {
                     like($call_res->[2], $test_args{call_actual_res_re},
                          "call actual res");
                 }
             }
 
             if ($test_args{calls}) {
                 my $i = 0;
                 for my $call (@{$test_args{calls}}) {
                     $i++;
                     subtest "call #$i: ".($call->{name} // "") => sub {
                         my $res;
                         eval { $res = $sub->(@{$call->{argsr}}) };
                         my $eval_err = $@;
                         if ($call->{dies}) {
                             ok($eval_err, "dies");
                             if ($call->{die_message}) {
                                 like($eval_err, $call->{die_message},
                                      "die message");
                             }
                             return;
                         } else {
                             ok(!$eval_err, "doesn't die")
                                 or diag $eval_err;
                         }
 
                         if (defined $call->{status}) {
                             is(ref($res), 'ARRAY', 'res is array')
                                 or diag "res = ", explain($res);
                             is($res->[0], $call->{status},
                                "status is $call->{status}")
                                 or diag "res = ", explain($res);
                         }
 
                         if (exists $call->{res}) {
                             is_deeply($res, $call->{res}, "res")
                                 or diag explain $res;
                         }
 
                         if (exists $call->{actual_res}) {
                             is_deeply($res->[2], $call->{actual_res}, "actual res")
                                 or diag explain $res->[2];
                         }
 
                         if (exists $call->{actual_res_re}) {
                             like($res->[2], $call->{actual_res_re},
                                  "actual res re");
                         }
                     }; 
                 }
             } 
 
             if ($test_args{posttest}) {
                 $test_args{posttest}->($wrap_res, $call_res, $sub);
             }
 
             done_testing();
 
         }; 
     } 
 }
 
 1;
 
 __END__
 
### Text/ANSI/BaseUtil.pm ###
 package Text::ANSI::BaseUtil;
 
 our $DATE = '2015-08-20'; 
 our $VERSION = '0.21'; 
 
 use 5.010001;
 use strict;
 use warnings;
 
 use List::Util qw(min max);
 
 our $re       = qr/\e\[[0-9;]+m/s;
 our $re_mult  = qr/(?:\e\[[0-9;]+m)+/s;
 
 sub ta_detect {
     my $text = shift;
     $text =~ $re ? 1:0;
 }
 
 sub ta_length {
     my $text = shift;
     length(ta_strip($text));
 }
 
 sub _ta_length_height {
     my ($is_mb, $text) = @_;
     my $num_lines = 0;
     my @lens;
     for my $e (split /(\r?\n)/, ta_strip($text)) {
         if ($e =~ /\n/) {
             $num_lines++;
             next;
         }
         $num_lines = 1 if $num_lines == 0;
         push @lens, $is_mb ? Text::WideChar::Util::mbswidth($e) : length($e);
     }
     [max(@lens) // 0, $num_lines];
 }
 
 sub ta_length_height {
     _ta_length_height(0, @_);
 }
 
 sub ta_mbswidth_height {
     _ta_length_height(1, @_);
 }
 
 sub ta_strip {
     my $text = shift;
     $text =~ s/$re//go;
     $text;
 }
 
 sub ta_extract_codes {
     my $text = shift;
     my $res = "";
     $res .= $1 while $text =~ /($re_mult)/go;
     $res;
 }
 
 sub ta_split_codes {
     my $text = shift;
     return split(/($re_mult)/o, $text);
 }
 
 sub ta_split_codes_single {
     my $text = shift;
     return split(/($re)/o, $text);
 }
 
 sub _ta_mbswidth0 {
     my $text = shift;
     Text::WideChar::Util::mbswidth(ta_strip($text));
 }
 
 sub ta_mbswidth {
     my $text = shift;
     ta_mbswidth_height($text)->[0];
 }
 
 sub _ta_wrap {
     my ($is_mb, $text, $width, $opts) = @_;
     $width //= 80;
     $opts  //= {};
 
 
     my $_re1 = $is_mb ?
         qr/($Text::WideChar::Util::re_cjk+)|(\S+)|(\s+)/ :
         qr/()(\S+)|(\s+)/;
 
     my $_re2 = $is_mb ?
         qr/($Text::WideChar::Util::re_cjk_class+)|
            ($Text::WideChar::Util::re_cjk_negclass+)/x : undef;
 
     my @termst; 
     my @terms;  
     my @pterms; 
     my @termsw; 
     my @termsc; 
     {
         my @ch = ta_split_codes_single($text);
         my $crcode = ""; 
         my $term      = '';
         my $pterm     = '';
         my $prev_type = '';
         while (my ($pt, $c) = splice(@ch, 0, 2)) {
 
 
             my @s; 
             while ($pt =~ /$_re1/g) {
                 if ($is_mb && $1) {
                     push @s, $1, 'c';
                 } elsif ($3) {
                     push @s, $3, 's';
                 } else {
                     if ($is_mb) {
                         my $pt2 = $2;
                         while ($pt2 =~ /$_re2/g) {
                             if ($1) {
                                 push @s, $1, 'c';
                             } else {
                                 push @s, $2, 'w';
                             }
                         }
                     } else {
                         push @s, $2, 'w';
                     }
                 }
             }
 
 
             my $only_code = 1 if !@s;
             while (1) {
                 my ($s, $s_type) = splice @s, 0, 2;
                 $s_type //= '';
                 last unless $only_code || defined($s);
                 if ($only_code) {
                     $s = "";
                     $term .= $c if defined $c;
                 }
 
                 if ($s_type && $s_type ne 's') {
                     if ($prev_type eq 's') {
                         push @termst, 's';
                         push @terms , $term;
                         push @pterms, $pterm;
                         push @termsw, undef;
                         push @termsc, $crcode;
                         $pterm = ''; $term = '';
                     } elsif ($prev_type && $prev_type ne $s_type) {
                         push @termst, $prev_type;
                         push @terms , $term;
                         push @pterms, $pterm;
                         push @termsw, $is_mb ? Text::WideChar::Util::mbswidth($pterm):length($pterm);
                         push @termsc, $crcode;
                         $pterm = ''; $term = '';
                     }
                     $pterm .= $s;
                     $term  .= $s; $term .= $c if defined($c) && !@s;
                     if (!@s && !@ch) {
                         push @termst, $s_type;
                         push @terms , $term;
                         push @pterms, "";
                         push @termsw, $is_mb ? Text::WideChar::Util::mbswidth($pterm):length($pterm);
                         push @termsc, $crcode;
                     }
                 } elsif (length($s)) {
                     if ($prev_type ne 's') {
                         push @termst, $prev_type;
                         push @terms , $term;
                         push @pterms, "";
                         push @termsw, $is_mb ? Text::WideChar::Util::mbswidth($pterm):length($pterm);
                         push @termsc, $crcode;
                         $pterm = ''; $term = '';
                     }
                     $pterm .= $s;
                     $term  .= $c if defined($c) && !@s;
                     if (!@s && !@ch) {
                         push @termst, 's';
                         push @terms , $term;
                         push @pterms, $pterm;
                         push @termsw, undef;
                         push @termsc, $crcode;
                     }
                 }
                 $prev_type = $s_type;
 
                 if (!@s) {
                     if (defined($c) && $c =~ /m\z/) {
                         if ($c eq "\e[0m") {
                             $crcode = "";
                         } elsif ($c =~ /m\z/) {
                             $crcode .= $c;
                         }
                     }
                     last if $only_code;
                 }
 
             } 
         } 
     }
 
     {
         my $i = 0;
         while ($i < @pterms) {
             if ($termst[$i] eq 's') {
                 if ($pterms[$i] =~ /[ \t]*(\n(?:[ \t]*\n)+)([ \t]*)/) {
                     $pterms[$i] = $1;
                     $termst[$i] = 'p';
                     if ($i < @pterms-1) {
                         $terms [$i+1] = $terms[$i] . $terms [$i+1];
                         $terms [$i] = "";
                     }
                     if (length $2) {
                         splice @termst, $i+1, 0, "s";
                         splice @terms , $i+1, 0, "";
                         splice @pterms, $i+1, 0, $2;
                         splice @termsw, $i+1, 0, undef;
                         splice @termsc, $i+1, 0, $termsc[$i];
                         $i += 2;
                         next;
                     }
                 }
             }
             $i++;
         }
     }
 
 
 
     my ($maxww, $minww);
 
 
     my @res;
     {
         my $tw = $opts->{tab_width} // 8;
         die "Please specify a positive tab width" unless $tw > 0;
         my $optfli  = $opts->{flindent};
         my $optfliw = Text::WideChar::Util::_get_indent_width($is_mb, $optfli, $tw) if defined $optfli;
         my $optsli  = $opts->{slindent};
         my $optsliw = Text::WideChar::Util::_get_indent_width($is_mb, $optsli, $tw) if defined $optsli;
         my $pad = $opts->{pad};
         my $x = 0;
         my $y = 0;
         my ($fli, $sli, $fliw, $sliw);
         my $is_parastart = 1;
         my $line_has_word = 0;
         my ($termt, $prev_t);
       TERM:
         for my $i (0..$#terms) {
             $prev_t = $termt if $i;
             $termt = $termst[$i];
             my $term  = $terms[$i];
             my $pterm = $pterms[$i];
             my $termw = $termsw[$i];
             my $crcode = $i > 0 ? $termsc[$i-1] : "";
 
             if ($termt eq 'p') {
                 my $numnl = 0;
                 $numnl++ while $pterm =~ /\n/g;
                 for (1..$numnl) {
                     push @res, "\e[0m" if $crcode && $_ == 1;
                     push @res, " " x ($width-$x) if $pad;
                     push @res, "\n";
                     $x = 0;
                     $y++;
                 }
                 $line_has_word = 0;
                 $x = 0;
                 $is_parastart = 1;
                 next TERM;
             }
 
             if ($is_parastart) {
                 if (defined $optfli) {
                     $fli  = $optfli;
                     $fliw = $optfliw;
                 } else {
                     if ($termt eq 's') {
                         $fli  = $pterm;
                         $fliw = Text::WideChar::Util::_get_indent_width($is_mb, $fli, $tw);
                     } else {
                         $fli  = "";
                         $fliw = 0;
                     }
                     my $j = $i;
                     $sli = undef;
                     while ($j < @terms && $termst[$j] ne 'p') {
                         if ($termst[$j] eq 's') {
                             if ($pterms[$j] =~ /\n([ \t]+)/) {
                                 $sli  = $1;
                                 $sliw = Text::WideChar::Util::_get_indent_width($is_mb, $sli, $tw);
                                 last;
                             }
                         }
                         $j++;
                     }
                     if (!defined($sli)) {
                         $sli  = "";
                         $sliw = 0;
                     }
                     die "Subsequent indent must be less than width" if $sliw >= $width;
                 }
 
                 push @res, $fli;
                 $x += $fliw;
             } 
 
             $is_parastart = 0;
 
             if ($termt eq 's') {
                 push @res, $term;
 
                 if ($pterm =~ /\n/ && $i == $#terms) {
                     push @res, "\e[0m" if $crcode;
                     push @res, " " x ($width-$x) if $pad;
                     push @res, "\n";
                     $line_has_word = 0;
                 }
             }
 
             if ($termt ne 's') {
                 my @words;
                 my @wordsw;
                 my @wordst; 
                 my @wordswsb; 
                 my $j = 0;
                 my $c = ""; 
                 while (1) {
                     $j++;
                     if ($termw <= $width-$sliw || $termt eq 'c') {
                         push @words   , $c . $term;
                         push @wordsw  , $termw;
                         push @wordst  , $termt;
                         push @wordswsb, ($prev_t && $prev_t eq 's')?1:0;
                         last;
                     }
                     my $res = $is_mb ? ta_mbtrunc($term, $width-$sliw, 1) :
                         ta_trunc($term, $width-$sliw, 1);
 
                     my ($tword, $twordw);
                     if ($j == 1) {
                         $tword  = $res->[0];
                         $twordw = $res->[1];
                     } else {
                         $tword  = ($crcode ? "\e[0m" . $crcode : "") .
                             $c . $res->[0];
                         $twordw = $res->[1];
                     }
                     $c .= ta_extract_codes(substr($term, 0, $res->[2]));
 
                     push @words   , $tword;
                     push @wordsw  , $twordw;
                     push @wordst  , $termt;
                     push @wordswsb, $j == 1 ? (($prev_t && $prev_t eq 's')?1:0) : 0;
                     $term  = substr($term, $res->[2]);
                     $termw = $is_mb ? _ta_mbswidth0($term) : ta_length($term);
                 }
 
 
                 for my $word (@words) {
                     my $wordw = shift @wordsw;
                     my $wordt = shift @wordst;
                     my $ws_before = shift @wordswsb;
 
                     $maxww = $wordw if !defined($maxww) || $maxww < $wordw;
                     $minww = $wordw if !defined($minww) || $minww > $wordw;
 
                     if ($x + ($line_has_word ? 1:0) + $wordw <= $width) {
                         if ($line_has_word && $ws_before) {
                             push @res, " ";
                             $x++;
                         }
                         push @res, $word;
                         $x += $wordw;
                     } else {
                         while (1) {
                             if ($wordt eq 'c') {
                                 my $res;
                                 if ($ws_before) {
                                     $res = ta_mbtrunc($word, $width-$x-1, 1);
                                     push @res, " ", $res->[0];
                                 } else {
                                     $res = ta_mbtrunc($word, $width-$x, 1);
                                     push @res, $res->[0];
                                 }
                                 $word = $res->[3];
                                 $wordw = _ta_mbswidth0($res->[3]);
                             } else {
                                 push @res, "\e[0m" if $crcode;
                             }
                             push @res, " " x ($width-$x) if $pad;
                             push @res, "\n";
                             $y++;
                             push @res, $crcode;
                             push @res, $sli;
 
                             if ($sliw + $wordw <= $width) {
                                 push @res, $word;
                                 $x = $sliw + $wordw;
                                 last;
                             } else {
                                 $x = $sliw;
                             }
                         }
                     }
                     $line_has_word++;
                 }
 
             }
         } 
         push @res, " " x ($width-$x) if $line_has_word && $pad;
     }
 
     if ($opts->{return_stats}) {
         return [join("", @res), {
             max_word_width => $maxww,
             min_word_width => $minww,
         }];
     } else {
         return join("", @res);
     }
 }
 
 sub ta_wrap {
     _ta_wrap(0, @_);
 }
 
 sub ta_mbwrap {
     _ta_wrap(1, @_);
 }
 
 sub _ta_pad {
     my ($is_mb, $text, $width, $which, $padchar, $is_trunc) = @_;
     if ($which) {
         $which = substr($which, 0, 1);
     } else {
         $which = "r";
     }
     $padchar //= " ";
 
     my $w = $is_mb ? _ta_mbswidth0($text) : ta_length($text);
     if ($is_trunc && $w > $width) {
         my $res = $is_mb ?
             ta_mbtrunc($text, $width, 1) : ta_trunc($text, $width, 1);
         $text = $res->[0] . ($padchar x ($width-$res->[1]));
     } else {
         if ($which eq 'l') {
             $text = ($padchar x ($width-$w)) . $text;
         } elsif ($which eq 'c') {
             my $n = int(($width-$w)/2);
             $text = ($padchar x $n) . $text . ($padchar x ($width-$w-$n));
         } else {
             $text .= ($padchar x ($width-$w));
         }
     }
     $text;
 }
 
 sub ta_pad {
     _ta_pad(0, @_);
 }
 
 sub ta_mbpad {
     _ta_pad(1, @_);
 }
 
 sub _ta_trunc {
     my ($is_mb, $text, $width, $return_extra) = @_;
 
 
     my $w = $is_mb ? _ta_mbswidth0($text) : ta_length($text);
     if ($w <= $width) {
         return $return_extra ? [$text, $w, length($text), ''] : $text;
     }
     my @p = ta_split_codes_single($text);
     my $res = '';
     my $append = 1; 
     my $code4rest = '';
     my $rest = '';
     $w = 0;
     my $c = 0;
     while (my ($t, $ansi) = splice @p, 0, 2) {
         if ($append) {
             my $tw = $is_mb ? Text::WideChar::Util::mbswidth($t) : length($t);
             if ($w+$tw <= $width) {
                 $res .= $t;
                 $w += $tw;
                 $c += length($t);
                 $append = 0 if $w == $width;
             } else {
                 my $tres = $is_mb ?
                     Text::WideChar::Util::mbtrunc($t, $width-$w, 1) :
                       [substr($t, 0, $width-$w), $width-$w, $width-$w];
                 $res .= $tres->[0];
                 $w += $tres->[1];
                 $c += $tres->[2];
                 $rest = substr($t, $tres->[2]);
                 $append = 0;
             }
         } else {
             $rest .= $t;
         }
         if (defined $ansi) {
             if ($append) {
                 if ($ansi eq "\e[0m") {
                     $c = length($ansi);
                     $code4rest = $ansi;
                 } else {
                     $c += length($ansi);
                     $code4rest .= $ansi;
                 }
                 $res .= $ansi;
             } else {
                 $res .= $ansi;
                 $rest .= $ansi;
             }
         }
     }
 
 
     if ($return_extra) {
         return [$res, $w, $c, $code4rest . $rest];
     } else {
         return $res;
     }
 }
 
 sub _ta_prune_codes {
     my $text = shift;
     $text =~ s/($re_mult)\e\[0m/\e\[0m/g;
     $text;
 }
 
 sub ta_trunc {
     _ta_trunc(0, @_);
 }
 
 sub ta_mbtrunc {
     _ta_trunc(1, @_);
 }
 
 sub _ta_highlight {
     my ($is_all, $text, $needle, $color) = @_;
 
     my (@chptext, @chcode, @chsavedc); 
     my $sc = "";
     my $plaintext = "";
     my @ch = ta_split_codes_single($text);
     while (my ($pt, $c) = splice(@ch, 0, 2)) {
         push @chptext , $pt;
         push @chcode  , $c;
         push @chsavedc, $sc;
         $plaintext .= $pt;
         if (defined($c) && $c =~ /m\z/) {
             if ($c eq "\e[0m") {
                 $sc = "";
             } elsif ($c =~ /m\z/) {
                 $sc .= $c;
             }
         }
     }
 
     my (@needle, @npos);
     if (ref($needle) eq 'Regexp') {
         my @m = $plaintext =~ /$needle/g;
         return $text unless @m;
         my $pos = 0;
         while ($pos < length($plaintext)) {
             my @pt;
             for (@m) {
                 my $p = index($plaintext, $_, $pos);
                 push @pt, [$p, $_] if $p >= 0;
             }
             last unless @pt;
             my $pmin = $pt[0][0];
             my $t = $pt[0][1];
             for (@pt) {
                 if ($pmin > $_->[0] ||
                         $pmin==$_->[0] && length($t) < length($_->[1])) {
                     $pmin = $_->[0];
                     $t = $_->[1];
                 }
             }
             push @needle, $t;
             push @npos  , $pmin;
             last unless $is_all;
             $pos = $pmin + length($t);
         }
     } else {
         my $pos = 0;
         while (1) {
             my $p = index($plaintext, $needle, $pos);
             last if $p < 0;
             push @needle, $needle;
             push @npos  , $p;
             last unless $is_all;
             $pos = $p + length($needle);
             last if $pos >= length($plaintext);
         }
         return $text unless @needle;
     }
 
     my @res;
     my $found = 1;
     my $pos = 0;
     my $i = 0;
     my $curneed = shift @needle;
     my $npos    = shift @npos;
   CHUNK:
     while (1) {
         last if $i >= @chptext;
         my $pos2  = $pos+length($chptext[$i])-1;
         my $npos2 = $npos+length($curneed)-1;
         if ($pos > $npos2 || $pos2 < $npos || !$found) {
             push @res, $chptext[$i];
             push @res, $chcode[$i] if defined $chcode[$i];
             goto L1;
         }
 
         if ($pos < $npos) {
             my $pre = substr($chptext[$i], 0, $npos-$pos);
             push @res, $pre;
         }
 
         my $npart = substr($curneed,
                            max(0, $pos-$npos),
                            min($pos2, $npos2)-max($pos, $npos)+1);
         if (length($npart)) {
             push @res, $color, $npart;
             push @res, "\e[0m";
             push @res, $chsavedc[$i];
         }
 
         if ($npos2 <= $pos2) {
             my $post = substr($chptext[$i], $npos2-$pos+1);
 
             if (@needle) {
                 $curneed = shift @needle;
                 $npos    = shift @npos;
                 $pos     = $npos2+1;
                 $chptext[$i] = $post;
                 $found = 1;
                 redo CHUNK;
             } else {
                 $found = 0;
             }
 
             if (!$found) {
                 push @res, $post;
                 push @res, $chcode[$i] if defined $chcode[$i];
             }
         }
 
       L1:
         $pos = $pos2+1;
         $i++;
     }
 
     join "", @res;
 }
 
 sub ta_highlight {
     _ta_highlight(0, @_);
 }
 
 sub ta_highlight_all {
     _ta_highlight(1, @_);
 }
 
 sub ta_add_color_resets {
     my (@text) = @_;
 
     my @res;
     my $i = 0;
     my $savedc = "";
     for my $text (@text) {
         $i++;
         my $newt = $i > 1 && !$savedc ? "\e[0m" : $savedc;
 
         my @ch = ta_split_codes_single($text);
         while (my ($t, $c) = splice(@ch, 0, 2)) {
             $newt .= $t;
             if (defined($c) && $c =~ /m\z/) {
                 $newt .= $c;
                 if ($c eq "\e[0m") {
                     $savedc = "";
                 } elsif ($c =~ /m\z/) {
                     $savedc .= $c;
                 }
             }
         }
 
         $newt .= "\e[0m" if $savedc && $i < @text;
         push @res, $newt;
     }
 
     @res;
 }
 
 sub _ta_substr {
     my $is_mb = shift;
     my $str   = shift;
     my $pos   = shift;
     my $len   = shift;
 
     my $res1 = _ta_trunc($is_mb, $str, $pos, 1);
     my $res2 = _ta_trunc($is_mb, $res1->[3], $len, 1);
 
     if (@_) {
         return _ta_prune_codes($res1->[0] . $_[0] . $res2->[3]);
     } else {
         return _ta_prune_codes($res2->[0]);
     }
 }
 
 sub ta_substr {
     _ta_substr(0, @_);
 }
 
 sub ta_mbsubstr {
     _ta_substr(1, @_);
 }
 
 
 1;
 
 __END__
 
### Text/ANSI/NonWideUtil.pm ###
 package Text::ANSI::NonWideUtil;
 
 our $DATE = '2015-08-20'; 
 our $VERSION = '0.21'; 
 
 use 5.010001;
 use strict 'subs', 'vars';
 use warnings;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(
                        ta_add_color_resets
                        ta_detect
                        ta_extract_codes
                        ta_highlight
                        ta_highlight_all
                        ta_length
                        ta_length_height
                        ta_pad
                        ta_split_codes
                        ta_split_codes_single
                        ta_strip
                        ta_substr
                        ta_trunc
                        ta_wrap
                );
 
 use Text::ANSI::BaseUtil ();
 
 our $re = $Text::ANSI::BaseUtil::re;
 *{$_} = \&{"Text::ANSI::BaseUtil::$_"} for @EXPORT_OK;
 
 1;
 
 __END__
 
### Text/ANSI/Util.pm ###
 package Text::ANSI::Util;
 
 our $DATE = '2015-08-20'; 
 our $VERSION = '0.21'; 
 
 use 5.010001;
 use strict 'subs', 'vars';
 use warnings;
 
 BEGIN {
     eval {
         require Text::WideChar::Util;
         Text::WideChar::Util->import(qw(mbswidth mbtrunc));
     };
     warn if $@;
 }
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT_OK = qw(
                        ta_add_color_resets
                        ta_detect
                        ta_extract_codes
                        ta_highlight
                        ta_highlight_all
                        ta_length
                        ta_length_height
                        ta_mbpad
                        ta_mbsubstr
                        ta_mbswidth
                        ta_mbswidth_height
                        ta_mbtrunc
                        ta_mbwrap
                        ta_pad
                        ta_split_codes
                        ta_split_codes_single
                        ta_strip
                        ta_substr
                        ta_trunc
                        ta_wrap
                );
 
 use Text::ANSI::BaseUtil ();
 
 our $re = $Text::ANSI::BaseUtil::re;
 *{$_} = \&{"Text::ANSI::BaseUtil::$_"} for @EXPORT_OK;
 
 1;
 
 __END__
 
### Text/ANSITable.pm ###
 package Text::ANSITable;
 
 our $DATE = '2015-10-22'; 
 our $VERSION = '0.46'; 
 
 use 5.010001;
 use Carp;
 use Log::Any::IfLOG '$log';
 use Moo;
 use experimental 'smartmatch';
 
 use Scalar::Util 'looks_like_number';
 
 my $ATTRS = [qw(
 
                   use_color color_depth use_box_chars use_utf8 columns rows
                   column_filter row_filter show_row_separator show_header
                   show_header cell_width cell_height cell_pad cell_lpad
                   cell_rpad cell_vpad cell_tpad cell_bpad cell_fgcolor
                   cell_bgcolor cell_align cell_valign header_align header_valign
                   header_vpad header_tpad header_bpad header_fgcolor
                   header_bgcolor color_theme_args border_style_args
 
           )];
 my $STYLES = $ATTRS;
 my $COLUMN_STYLES = [qw(
 
                           type width align valign pad lpad rpad formats fgcolor
                           bgcolor wrap
 
                   )];
 my $ROW_STYLES = [qw(
 
                        height align valign vpad tpad bpad fgcolor bgcolor
 
                )];
 my $CELL_STYLES = [qw(
 
                         align valign formats fgcolor bgcolor
 
                 )];
 
 has columns => (
     is      => 'rw',
     default => sub { [] },
     trigger => sub {
         my $self = shift;
         $self->{_columns_set}++;
     },
 );
 has rows => (
     is      => 'rw',
     default => sub { [] },
     trigger => sub {
         my ($self, $rows) = @_;
         $self->_set_default_cols($rows->[0]);
     },
 );
 has column_filter => (
     is => 'rw',
 );
 has column_wrap => (
     is => 'rw',
 );
 has row_filter => (
     is => 'rw',
 );
 has _row_separators => ( 
     is      => 'rw',
     default => sub { [] },
 );
 has show_row_separator => (
     is      => 'rw',
     default => sub { 2 },
 );
 has show_header => (
     is      => 'rw',
     default => sub { 1 },
 );
 
 has _column_styles => ( 
     is      => 'rw',
     default => sub { [] },
 );
 has _row_styles => ( 
     is      => 'rw',
     default => sub { [] },
 );
 has _cell_styles => ( 
     is      => 'rw',
     default => sub { [] },
 );
 
 
 has _cond_column_styles => ( 
     is      => 'rw',
     default => sub { [] },
 );
 has _cond_row_styles => ( 
     is      => 'rw',
     default => sub { [] },
 );
 has _cond_cell_styles => ( 
     is      => 'rw',
     default => sub { [] },
 );
 
 has cell_width => (
     is      => 'rw',
 );
 has cell_height => (
     is      => 'rw',
 );
 has cell_pad => (
     is      => 'rw',
     default => sub { 1 },
 );
 has cell_lpad => (
     is      => 'rw',
 );
 has cell_rpad => (
     is      => 'rw',
 );
 has cell_vpad => (
     is      => 'rw',
     default => sub { 0 },
 );
 has cell_tpad => (
     is      => 'rw',
 );
 has cell_bpad => (
     is      => 'rw',
 );
 has cell_fgcolor => (
     is => 'rw',
 );
 has cell_bgcolor => (
     is => 'rw',
 );
 has cell_align => (
     is => 'rw',
 );
 has cell_valign => (
     is => 'rw',
 );
 
 has header_align => (
     is      => 'rw',
 );
 has header_valign => (
     is      => 'rw',
 );
 has header_vpad => (
     is      => 'rw',
 );
 has header_tpad => (
     is      => 'rw',
 );
 has header_bpad => (
     is      => 'rw',
 );
 has header_fgcolor => (
     is      => 'rw',
 );
 has header_bgcolor => (
     is      => 'rw',
 );
 
 with 'Border::Style::Role';
 with 'Color::Theme::Role::ANSI';
 with 'Term::App::Role::Attrs';
 
 sub BUILD {
     my ($self, $args) = @_;
 
     if ($ENV{ANSITABLE_STYLE_SETS}) {
         require JSON;
         my $sets = JSON::decode_json($ENV{ANSITABLE_STYLE_SETS});
         croak "ANSITABLE_STYLE_SETS must be an array"
             unless ref($sets) eq 'ARRAY';
         for my $set (@$sets) {
             if (ref($set) eq 'ARRAY') {
                 $self->apply_style_set($set->[0], $set->[1]);
             } else {
                 $self->apply_style_set($set);
             }
         }
     }
 
     if ($ENV{ANSITABLE_STYLE}) {
         require JSON;
         my $s = JSON::decode_json($ENV{ANSITABLE_STYLE});
         for my $k (keys %$s) {
             my $v = $s->{$k};
             croak "Unknown table style '$k' in ANSITABLE_STYLE environment, ".
                 "please use one of [".join(", ", @$STYLES)."]"
                     unless $k ~~ $STYLES;
             $self->{$k} = $v;
         }
     }
 
     if ($args->{border_style}) { $self->border_style($args->{border_style}) }
     if ($args->{color_theme}) { $self->color_theme($args->{color_theme}) }
 
     unless ($self->{border_style}) {
         my $bs;
 
         my $use_utf8 = $self->use_utf8;
 
         my $emu_eng  = $self->detect_terminal->{emulator_engine} // '';
         my $linux_vc = $emu_eng eq 'linux' && !defined($ENV{UTF8});
         if ($linux_vc) {
             $use_utf8 = 1;
             $bs = 'Default::singleo_utf8';
         }
         local $self->{use_utf8} = 1 if $linux_vc;
 
         unless (defined $ENV{UTF8}) {
             require PerlIO;
             my @layers = PerlIO::get_layers(STDOUT);
             $use_utf8 = 0 unless 'utf8' ~~ @layers;
         }
 
         if (defined $ENV{ANSITABLE_BORDER_STYLE}) {
             $bs = $ENV{ANSITABLE_BORDER_STYLE};
         } elsif ($use_utf8) {
             $bs //= 'Default::bricko';
         } elsif ($self->use_box_chars) {
             $bs = 'Default::singleo_boxchar';
         } else {
             $bs = 'Default::singleo_ascii';
         }
 
         $self->border_style($bs);
     }
 
     unless ($self->{color_theme}) {
         my $ct;
         if (defined $ENV{ANSITABLE_COLOR_THEME}) {
             $ct = $ENV{ANSITABLE_COLOR_THEME};
         } elsif ($self->use_color) {
             my $bg = $self->detect_terminal->{default_bgcolor} // '';
             if ($self->color_depth >= 2**24) {
                 $ct = 'Default::default_gradation' .
                     ($bg eq 'ffffff' ? '_whitebg' : '');
             } else {
                 $ct = 'Default::default_nogradation' .
                     ($bg eq 'ffffff' ? '_whitebg' : '');;
             }
         } else {
             $ct = 'Default::no_color';
         }
         $self->color_theme($ct);
     }
 
     unless (defined $self->{wide}) {
         $self->{wide} = eval { require Text::ANSI::WideUtil; 1 } ? 1:0;
     }
     require Text::ANSI::NonWideUtil;
     $self->{_func_add_color_resets} = \&Text::ANSI::NonWideUtil::ta_add_color_resets;
     if ($self->{wide}) {
         require Text::ANSI::WideUtil;
         $self->{_func_length_height} = \&Text::ANSI::WideUtil::ta_mbswidth_height;
         $self->{_func_pad}           = \&Text::ANSI::WideUtil::ta_mbpad;
         $self->{_func_wrap}          = \&Text::ANSI::WideUtil::ta_mbwrap;
     } else {
         $self->{_func_length_height} = \&Text::ANSI::NonWideUtil::ta_length_height;
         $self->{_func_pad}           = \&Text::ANSI::NonWideUtil::ta_pad;
         $self->{_func_wrap}          = \&Text::ANSI::NonWideUtil::ta_wrap;
     }
 }
 
 sub _set_default_cols {
     my ($self, $row) = @_;
     return if $self->{_columns_set}++;
     $self->columns([map {"col$_"} 0..@$row-1]) if $row;
 }
 
 sub add_row {
     my ($self, $row, $styles) = @_;
     croak "Row must be arrayref" unless ref($row) eq 'ARRAY';
     push @{ $self->{rows} }, $row;
     $self->_set_default_cols($row) unless $self->{_columns_set}++;
     if ($styles) {
         my $i = @{ $self->{rows} }-1;
         for my $s (keys %$styles) {
             $self->set_row_style($i, $s, $styles->{$s});
         }
     }
     $self;
 }
 
 sub add_row_separator {
     my ($self) = @_;
     my $idx = ~~@{$self->{rows}}-1;
     push @{ $self->{_row_separators} }, $idx
         unless @{ $self->{_row_separators} } &&
             $self->{_row_separators}[-1] == $idx;
     $self;
 }
 
 sub add_rows {
     my ($self, $rows, $styles) = @_;
     croak "Rows must be arrayref" unless ref($rows) eq 'ARRAY';
     $self->add_row($_, $styles) for @$rows;
     $self;
 }
 
 sub _colnum {
     my $self = shift;
     my $colname = shift;
 
     return $colname if looks_like_number($colname);
     my $cols = $self->{columns};
     for my $i (0..@$cols-1) {
         return $i if $cols->[$i] eq $colname;
     }
     croak "Unknown column name '$colname'";
 }
 
 sub get_cell {
     my ($self, $row_num, $col) = @_;
 
     $col = $self->_colnum($col);
 
     $self->{rows}[$row_num][$col];
 }
 
 sub set_cell {
     my ($self, $row_num, $col, $val) = @_;
 
     $col = $self->_colnum($col);
 
     my $oldval = $self->{rows}[$row_num][$col];
     $self->{rows}[$row_num][$col] = $val;
     $oldval;
 }
 
 sub get_column_style {
     my ($self, $col, $style) = @_;
 
     $col = $self->_colnum($col);
     $self->{_column_styles}[$col]{$style};
 }
 
 sub set_column_style {
     my $self = shift;
     my $col  = shift;
 
     $col = $self->_colnum($col);
 
     my %sets = ref($_[0]) eq 'HASH' ? %{$_[0]} : @_;
 
     for my $style (keys %sets) {
         my $val = $sets{$style};
         croak "Unknown per-column style '$style', please use one of [".
             join(", ", @$COLUMN_STYLES) . "]" unless $style ~~ $COLUMN_STYLES;
         $self->{_column_styles}[$col]{$style} = $val;
     }
 }
 
 sub get_cond_column_styles {
     my $self = shift;
     $self->{_cond_column_styles};
 }
 
 
 sub add_cond_column_style {
     my $self = shift;
     my $cond = shift;
     if (ref($cond) ne 'CODE') {
         croak "cond must be a coderef";
     }
 
     my $styles;
     if (ref($_[0]) eq 'HASH') {
         $styles = shift;
     } else {
         $styles = { @_ };
     }
 
     for my $style (keys %$styles) {
         croak "Unknown per-column style '$style', please use one of [".
             join(", ", @$COLUMN_STYLES) . "]" unless $style ~~ $COLUMN_STYLES;
     }
 
     push @{ $self->{_cond_column_styles} }, [$cond, $styles];
 }
 
 
 sub get_eff_column_style {
     my ($self, $col, $style) = @_;
 
     $col = $self->_colnum($col);
 
     if (defined $self->{_draw}{eff_column_styles}[$col]) {
         return $self->{_draw}{eff_column_styles}[$col]{$style};
     }
 
     my $cols = $self->{columns};
     my %styles;
 
   COND:
     for my $ei (0..@{ $self->{_cond_column_styles} }-1) {
         my $e = $self->{_cond_column_styles}[$ei];
         local $_ = $col;
         my $res = $e->[0]->(
             $self,
             col     => $col,
             colname => $cols->[$col],
         );
         next COND unless $res;
         if (ref($res) eq 'HASH') {
             $styles{$_} = $res->{$_} for keys %$res;
         }
         $styles{$_} = $e->[1]{$_} for keys %{ $e->[1] };
     }
 
     my $rss = $self->{_column_styles}[$col];
     if ($rss) {
         $styles{$_} = $rss->{$_} for keys %$rss;
     }
 
     $self->{_draw}{eff_column_styles}[$col] = \%styles;
 
     $styles{$style};
 }
 
 sub get_row_style {
     my ($self, $row, $style) = @_;
 
     $self->{_row_styles}[$row]{$style};
 }
 
 sub set_row_style {
     my $self = shift;
     my $row  = shift;
 
     my %sets = ref($_[0]) eq 'HASH' ? %{$_[0]} : @_;
 
     for my $style (keys %sets) {
         my $val = $sets{$style};
         croak "Unknown per-row style '$style', please use one of [".
             join(", ", @$ROW_STYLES) . "]" unless $style ~~ $ROW_STYLES;
         $self->{_row_styles}[$row]{$style} = $val;
     }
 }
 
 sub get_cond_row_styles {
     my $self = shift;
     $self->{_cond_row_styles};
 }
 
 
 sub add_cond_row_style {
     my $self = shift;
     my $cond = shift;
     if (ref($cond) ne 'CODE') {
         croak "cond must be a coderef";
     }
 
     my $styles;
     if (ref($_[0]) eq 'HASH') {
         $styles = shift;
     } else {
         $styles = { @_ };
     }
 
     for my $style (keys %$styles) {
         croak "Unknown per-row style '$style', please use one of [".
             join(", ", @$ROW_STYLES) . "]" unless $style ~~ $ROW_STYLES;
     }
 
     push @{ $self->{_cond_row_styles} }, [$cond, $styles];
 }
 
 
 sub get_eff_row_style {
     my ($self, $row, $style) = @_;
 
     if (defined $self->{_draw}{eff_row_styles}[$row]) {
         return $self->{_draw}{eff_row_styles}[$row]{$style};
     }
 
     my $rows = $self->{rows};
     my %styles;
 
   COND:
     for my $ei (0..@{ $self->{_cond_row_styles} }-1) {
         my $e = $self->{_cond_row_styles}[$ei];
         local $_ = $row;
         my $res = $e->[0]->(
             $self,
             row      => $row,
             row_data => $rows->[$row],
         );
         next COND unless $res;
         if (ref($res) eq 'HASH') {
             $styles{$_} = $res->{$_} for keys %$res;
         }
         $styles{$_} = $e->[1]{$_} for keys %{ $e->[1] };
     }
 
     my $rss = $self->{_row_styles}[$row];
     if ($rss) {
         $styles{$_} = $rss->{$_} for keys %$rss;
     }
 
     $self->{_draw}{eff_row_styles}[$row] = \%styles;
 
     $styles{$style};
 }
 
 sub get_cell_style {
     my ($self, $row, $col, $style) = @_;
 
     $col = $self->_colnum($col);
     $self->{_cell_styles}[$row][$col]{$style};
 }
 
 sub set_cell_style {
     my $self = shift;
     my $row  = shift;
     my $col  = shift;
 
     $col = $self->_colnum($col);
 
     my %sets = ref($_[0]) eq 'HASH' ? %{$_[0]} : @_;
 
     for my $style (keys %sets) {
         my $val = $sets{$style};
         croak "Unknown per-cell style '$style', please use one of [".
             join(", ", @$CELL_STYLES) . "]" unless $style ~~ $CELL_STYLES;
         $self->{_cell_styles}[$row][$col]{$style} = $val;
     }
 }
 
 sub get_cond_cell_styles {
     my $self = shift;
     $self->{_cond_cell_styles};
 }
 
 
 sub add_cond_cell_style {
     my $self = shift;
     my $cond = shift;
     if (ref($cond) ne 'CODE') {
         croak "cond must be a coderef";
     }
 
     my $styles;
     if (ref($_[0]) eq 'HASH') {
         $styles = shift;
     } else {
         $styles = { @_ };
     }
 
     for my $style (keys %$styles) {
         croak "Unknown per-cell style '$style', please use one of [".
             join(", ", @$CELL_STYLES) . "]" unless $style ~~ $CELL_STYLES;
     }
 
     push @{ $self->{_cond_cell_styles} }, [$cond, $styles];
 }
 
 
 sub get_eff_cell_style {
     my ($self, $row, $col, $style) = @_;
 
     if (defined $self->{_draw}{eff_cell_styles}[$row][$col]) {
         return $self->{_draw}{eff_cell_styles}[$row][$col]{$style};
     }
 
     my $rows = $self->{rows};
     my %styles;
 
   COND:
     for my $ei (0..@{ $self->{_cond_cell_styles} }-1) {
         my $e = $self->{_cond_cell_styles}[$ei];
         local $_ = $rows->[$row][$col];
         my $res = $e->[0]->(
             $self,
             content  => $_,
             col      => $col,
             row      => $row,
             row_data => $rows->[$row],
         );
         next COND unless $res;
         if (ref($res) eq 'HASH') {
             $styles{$_} = $res->{$_} for keys %$res;
         }
         $styles{$_} = $e->[1]{$_} for keys %{ $e->[1] };
     }
 
     my $css = $self->{_cell_styles}[$row][$col];
     if ($css) {
         $styles{$_} = $css->{$_} for keys %$css;
     }
 
     $self->{_draw}{eff_cell_styles}[$row][$col] = \%styles;
 
     $styles{$style};
 }
 
 sub apply_style_set {
     my $self = shift;
     my $name = shift;
     $name =~ /\A[A-Za-z0-9_]+(?:::[A-Za-z0-9_]+)*\z/
         or croak "Invalid style set name, please use alphanums only";
     {
         my $name = $name;
         $name =~ s!::!/!g;
         require "Text/ANSITable/StyleSet/$name.pm";
     }
     my %args = ref($_[0]) eq 'HASH' ? %{$_[0]} : @_;
     my $obj = "Text::ANSITable::StyleSet::$name"->new(%args);
     $obj->apply($self);
 }
 
 sub list_style_sets {
     require Module::List;
     require Module::Load;
     require Package::MoreUtil;
 
     my ($self, $detail) = @_;
 
     my $prefix = (ref($self) ? ref($self) : $self ) .
         '::StyleSet'; 
     my $all_sets = $self->{_all_style_sets};
 
     if (!$all_sets) {
         my $mods = Module::List::list_modules("$prefix\::",
                                               {list_modules=>1, recurse=>1});
         $all_sets = {};
         for my $mod (sort keys %$mods) {
             Module::Load::load($mod);
             my $name = $mod; $name =~ s/\A\Q$prefix\:://;
             my $summary = $mod->summary;
             my %ct = Package::MoreUtil::list_package_contents($mod);
             my $args = [sort grep {!/\W/ && !/\A(new|summary|apply)\z/}
                             keys %ct];
             $all_sets->{$name} = {name=>$name, summary=>$summary, args=>$args};
         }
         $self->{_all_style_sets} = $all_sets;
     }
 
     if ($detail) {
         return $all_sets;
     } else {
         return sort keys %$all_sets;
     }
 }
 
 sub _read_style_envs {
     my $self = shift;
 
     next if $self->{_read_style_envs}++;
 
     if ($ENV{ANSITABLE_COLUMN_STYLES}) {
         require JSON;
         my $ss = JSON::decode_json($ENV{ANSITABLE_COLUMN_STYLES});
         croak "ANSITABLE_COLUMN_STYLES must be a hash"
             unless ref($ss) eq 'HASH';
         for my $col (keys %$ss) {
             my $ci = $self->_colnum($col);
             my $s = $ss->{$col};
             for my $k (keys %$s) {
                 my $v = $s->{$k};
             croak "Unknown column style '$k' (for column $col) in ".
                 "ANSITABLE_COLUMN_STYLES environment, ".
                     "please use one of [".join(", ", @$COLUMN_STYLES)."]"
                         unless $k ~~ $COLUMN_STYLES;
                 $self->{_column_styles}[$ci]{$k} //= $v;
             }
         }
     }
 
     if ($ENV{ANSITABLE_ROW_STYLES}) {
         require JSON;
         my $ss = JSON::decode_json($ENV{ANSITABLE_ROW_STYLES});
         croak "ANSITABLE_ROW_STYLES must be a hash"
             unless ref($ss) eq 'HASH';
         for my $row (keys %$ss) {
             my $s = $ss->{$row};
             for my $k (keys %$s) {
                 my $v = $s->{$k};
             croak "Unknown row style '$k' (for row $row) in ".
                 "ANSITABLE_ROW_STYLES environment, ".
                     "please use one of [".join(", ", @$ROW_STYLES)."]"
                         unless $k ~~ $ROW_STYLES;
                 $self->{_row_styles}[$row]{$k} //= $v;
             }
         }
     }
 
     if ($ENV{ANSITABLE_CELL_STYLES}) {
         require JSON;
         my $ss = JSON::decode_json($ENV{ANSITABLE_CELL_STYLES});
         croak "ANSITABLE_CELL_STYLES must be a hash"
             unless ref($ss) eq 'HASH';
         for my $cell (keys %$ss) {
             croak "Invalid cell specification in ANSITABLE_CELL_STYLES: ".
                 "$cell, please use 'row,col'"
                     unless $cell =~ /^(.+),(.+)$/;
             my $row = $1;
             my $col = $2;
             my $ci = $self->_colnum($col);
             my $s = $ss->{$cell};
             for my $k (keys %$s) {
                 my $v = $s->{$k};
             croak "Unknown cell style '$k' (for cell $row,$col) in ".
                 "ANSITABLE_CELL_STYLES environment, ".
                     "please use one of [".join(", ", @$CELL_STYLES)."]"
                         unless $k ~~ $CELL_STYLES;
                 $self->{_cell_styles}[$row][$ci]{$k} //= $v;
             }
         }
     }
 }
 
 sub _calc_fcols {
     my $self = shift;
 
     my $cols = $self->{columns};
     my $cf   = $self->{column_filter};
 
     my $fcols;
     if (ref($cf) eq 'CODE') {
         $fcols = [grep {$cf->($_)} @$cols];
     } elsif (ref($cf) eq 'ARRAY') {
         $fcols = [grep {defined} map {looks_like_number($_) ?
                                           $cols->[$_] : $_} @$cf];
     } else {
         $fcols = $cols;
     }
     $self->{_draw}{fcols} = $fcols;
 }
 
 sub _calc_header_height {
     my $self = shift;
 
     my $cols  = $self->{columns};
     my $fcols = $self->{_draw}{fcols};
 
     my $fcol_widths = []; 
     my $header_height = 1;
     my $fcol_lpads  = []; 
     my $fcol_rpads  = []; 
     my $fcol_setwidths  = []; 
     my $frow_setheights = []; 
 
     my %seen;
     my $lpad = $self->{cell_lpad} // $self->{cell_pad}; 
     my $rpad = $self->{cell_rpad} // $self->{cell_pad}; 
     for my $i (0..@$cols-1) {
         next unless $cols->[$i] ~~ $fcols;
         next if $seen{$cols->[$i]}++;
 
         $fcol_setwidths->[$i] = $self->get_eff_column_style($i, 'width') //
             $self->{cell_width};
         my $wh = $self->_opt_calc_cell_width_height(undef, $i, $cols->[$i]);
         $fcol_widths->[$i] = $wh->[0];
         $header_height = $wh->[1]
             if !defined($header_height) || $header_height < $wh->[1];
         $fcol_lpads->[$i] = $self->get_eff_column_style($i, 'lpad') //
             $self->get_eff_column_style($i, 'pad') // $lpad;
         $fcol_rpads->[$i] = $self->get_eff_column_style($i, 'rpad') //
             $self->get_eff_column_style($i, 'pad') // $rpad;
     }
 
     $self->{_draw}{header_height}   = $header_height;
     $self->{_draw}{fcol_lpads}      = $fcol_lpads;
     $self->{_draw}{fcol_rpads}      = $fcol_rpads;
     $self->{_draw}{fcol_setwidths}  = $fcol_setwidths;
     $self->{_draw}{frow_setheights} = $frow_setheights;
     $self->{_draw}{fcol_widths}     = $fcol_widths;
 }
 
 sub _calc_frows {
     my $self = shift;
 
     my $rows = $self->{rows};
     my $rf   = $self->{row_filter};
     my $frow_setheights = $self->{_draw}{frow_setheights};
 
     my $frow_tpads  = []; 
     my $frow_bpads  = []; 
     my $frows = [];
     my $frow_separators = [];
     my $frow_orig_indices = []; 
 
     my $tpad = $self->{cell_tpad} // $self->{cell_vpad}; 
     my $bpad = $self->{cell_bpad} // $self->{cell_vpad}; 
     my $i = -1;
     my $j = -1;
     for my $row (@$rows) {
         $i++;
         if (ref($rf) eq 'CODE') {
             next unless $rf->($row, $i);
         } elsif ($rf) {
             next unless $i ~~ $rf;
         }
         $j++;
         push @$frow_setheights, $self->get_eff_row_style($i, 'height') //
             $self->{cell_height};
         push @$frows, [@$row]; 
         push @$frow_separators, $j if $i ~~ $self->{_row_separators};
         push @$frow_tpads, $self->get_eff_row_style($i, 'tpad') //
             $self->get_eff_row_style($i, 'vpad') // $tpad;
         push @$frow_bpads, $self->get_eff_row_style($i, 'bpad') //
             $self->get_eff_row_style($i, 'vpad') // $bpad;
         push @$frow_orig_indices, $i;
     }
 
     $self->{_draw}{frows}             = $frows;
     $self->{_draw}{frow_separators}   = $frow_separators;
     $self->{_draw}{frow_tpads}        = $frow_tpads;
     $self->{_draw}{frow_bpads}        = $frow_bpads;
     $self->{_draw}{frow_orig_indices} = $frow_orig_indices;
 }
 
 sub _detect_column_types {
     my $self = shift;
 
     my $cols = $self->{columns};
     my $rows = $self->{rows};
     my $ct   = $self->{color_theme};
 
     my $fcol_detect = [];
     my %seen;
     for my $i (0..@$cols-1) {
         my $col = $cols->[$i];
         my $res = {};
         $fcol_detect->[$i] = $res;
 
         next unless $col ~~ $self->{_draw}{fcols};
 
         my $type = $self->get_eff_column_style($col, 'type');
         my $subtype;
       DETECT:
         {
             last DETECT if $type;
             if ($col =~ /^(can|is|has|does)_|\?$/) {
                 $type = 'bool';
                 last DETECT;
             }
 
             require Parse::VarName;
             my @words = map {lc} @{ Parse::VarName::split_varname_words(
                 varname=>$col) };
             for (qw/date time ctime mtime utime atime stime/) {
                 if ($_ ~~ @words) {
                     $type = 'date';
                     last DETECT;
                 }
             }
 
             my $pass = 1;
             for my $j (0..@$rows) {
                 my $v = $rows->[$j][$i];
                 next unless defined($v);
                 do { $pass=0; last } unless looks_like_number($v);
             }
             if ($pass) {
                 $type = 'num';
                 if ($col =~ /(pct|percent(?:age))\b|\%/) {
                     $subtype = 'pct';
                 }
                 last DETECT;
             }
             $type = 'str';
         } 
 
         $res->{type} = $type;
         if ($type eq 'bool') {
             $res->{align}   = 'center';
             $res->{valign}  = 'center';
             $res->{fgcolor} = $ct->{colors}{bool_data};
             $res->{formats} = [[bool => {style => $self->{use_utf8} ?
                                              "check_cross" : "Y_N"}]];
         } elsif ($type eq 'date') {
             $res->{align}   = 'middle';
             $res->{fgcolor} = $ct->{colors}{date_data};
             $res->{formats} = [['date' => {}]];
         } elsif ($type =~ /\A(num|float|int)\z/) {
             $res->{align}   = 'right';
             $res->{fgcolor} = $ct->{colors}{num_data};
             if (($subtype//"") eq 'pct') {
                 $res->{formats} = [[num => {style=>'percent'}]];
             }
         } else {
             $res->{fgcolor} = $ct->{colors}{str_data};
             $res->{wrap}    = $ENV{WRAP} // 1;
         }
     }
 
     $self->{_draw}{fcol_detect} = $fcol_detect;
 }
 
 sub _opt_calc_cell_width_height {
     my ($self, $frow_num, $col, $text) = @_;
 
     $col = $self->_colnum($col);
     my $setw  = $self->{_draw}{fcol_setwidths}[$col];
     my $calcw = !defined($setw) || $setw < 0;
     my $seth  = defined($frow_num) ?
         $self->{_draw}{frow_setheights}[$frow_num] : undef;
     my $calch = !defined($seth) || $seth < 0;
 
     my $wh;
     if ($calcw) {
         $wh = $self->{_func_length_height}->($text);
         $wh->[0] = -$setw if defined($setw) && $setw<0 && $wh->[0] < -$setw;
         $wh->[1] = $seth if !$calch;
         $wh->[1] = -$seth if defined($seth) && $seth<0 && $wh->[1] < -$seth;
     } elsif ($calch) {
         my $h = 1; $h++ while $text =~ /\n/go;
         $h = -$seth if defined($seth) && $seth<0 && $h < -$seth;
         $wh = [$setw, $h];
     } else {
         $wh = [$setw, $seth];
     }
     $wh;
 }
 
 sub _apply_column_formats {
     my $self = shift;
 
     my $cols  = $self->{columns};
     my $frows = $self->{_draw}{frows};
     my $fcols = $self->{_draw}{fcols};
     my $fcol_detect = $self->{_draw}{fcol_detect};
 
     my %seen;
     for my $i (0..@$cols-1) {
         next unless $cols->[$i] ~~ $fcols;
         next if $seen{$cols->[$i]}++;
         my @fmts = @{ $self->get_eff_column_style($i, 'formats') //
                           $fcol_detect->[$i]{formats} // [] };
         if (@fmts) {
             require Data::Unixish::Apply;
             my $res = Data::Unixish::Apply::apply(
                 in => [map {$frows->[$_][$i]} 0..@$frows-1],
                 functions => \@fmts,
             );
             croak "Can't format column $cols->[$i]: $res->[0] - $res->[1]"
                 unless $res->[0] == 200;
             $res = $res->[2];
             for (0..@$frows-1) { $frows->[$_][$i] = $res->[$_] // "" }
         } else {
             for (0..@$frows-1) { $frows->[$_][$i] //= "" }
         }
     }
 }
 
 sub _apply_cell_formats {
     my $self = shift;
 
     my $cols  = $self->{columns};
     my $rows  = $self->{rows};
     my $fcols = $self->{_draw}{fcols};
     my $frows = $self->{_draw}{frows};
     my $frow_orig_indices = $self->{_draw}{frow_orig_indices};
 
     for my $i (0..@$frows-1) {
         my %seen;
         my $origi = $frow_orig_indices->[$i];
         for my $j (0..@$cols-1) {
             next unless $cols->[$j] ~~ $fcols;
             next if $seen{$cols->[$j]}++;
 
             my $fmts = $self->get_eff_cell_style($origi, $j, 'formats');
             if (defined $fmts) {
                 require Data::Unixish::Apply;
                 my $res = Data::Unixish::Apply::apply(
                     in => [ $frows->[$i][$j] ],
                     functions => $fmts,
                 );
                 croak "Can't format cell ($origi, $cols->[$j]): ".
                     "$res->[0] - $res->[1]" unless $res->[0] == 200;
                 $frows->[$i][$j] = $res->[2][0] // "";
             }
         } 
     }
 }
 
 sub _calc_row_widths_heights {
     my $self = shift;
 
     my $cols  = $self->{columns};
     my $fcols = $self->{_draw}{fcols};
     my $frows = $self->{_draw}{frows};
 
     my $frow_heights = [];
     my $fcol_widths  = $self->{_draw}{fcol_widths};
     my $frow_orig_indices = $self->{_draw}{frow_orig_indices};
 
     my $height = $self->{cell_height};
     my $tpad = $self->{cell_tpad} // $self->{cell_vpad}; 
     my $bpad = $self->{cell_bpad} // $self->{cell_vpad}; 
     my $cswidths = [map {$self->get_eff_column_style($_, 'width')} 0..@$cols-1];
     for my $i (0..@$frows-1) {
         my %seen;
         my $origi = $frow_orig_indices->[$i];
         my $rsheight = $self->get_eff_row_style($origi, 'height');
         for my $j (0..@$cols-1) {
             next unless $cols->[$j] ~~ $fcols;
             next if $seen{$cols->[$j]}++;
 
             my $wh = $self->_opt_calc_cell_width_height($i,$j,$frows->[$i][$j]);
 
             $fcol_widths->[$j]  = $wh->[0] if $fcol_widths->[$j] < $wh->[0];
             $frow_heights->[$i] = $wh->[1] if !defined($frow_heights->[$i])
                 || $frow_heights->[$i] < $wh->[1];
         } 
     }
     $self->{_draw}{frow_heights}  = $frow_heights;
 }
 
 sub _wrap_wrappable_columns {
     my $self = shift;
 
     my $cols  = $self->{columns};
     my $fcols = $self->{_draw}{fcols};
     my $frows = $self->{_draw}{frows};
     my $fcol_detect    = $self->{_draw}{fcol_detect};
     my $fcol_setwidths = $self->{_draw}{fcol_setwidths};
 
     my %seen;
     for my $i (0..@$cols-1) {
         next unless $cols->[$i] ~~ $fcols;
         next if $seen{$cols->[$i]}++;
 
         if (($self->get_eff_column_style($i, 'wrap') // $self->{column_wrap} //
                  $fcol_detect->[$i]{wrap}) &&
                      defined($fcol_setwidths->[$i]) &&
                          $fcol_setwidths->[$i]>0) {
             for (0..@$frows-1) {
                 $frows->[$_][$i] = $self->{_func_wrap}->(
                     $frows->[$_][$i], $fcol_setwidths->[$i]);
             }
         }
     }
 }
 
 sub _calc_table_width_height {
     my $self = shift;
 
     my $cols  = $self->{columns};
     my $fcols = $self->{_draw}{fcols};
     my $frows = $self->{_draw}{frows};
     my $fcol_widths  = $self->{_draw}{fcol_widths};
     my $fcol_lpads   = $self->{_draw}{fcol_lpads};
     my $fcol_rpads   = $self->{_draw}{fcol_rpads};
     my $frow_tpads   = $self->{_draw}{frow_tpads};
     my $frow_bpads   = $self->{_draw}{frow_bpads};
     my $frow_heights = $self->{_draw}{frow_heights};
 
     my $w = 0;
     $w += 1 if length($self->get_border_char(3, 0));
     my $has_vsep = length($self->get_border_char(3, 1));
     for my $i (0..@$cols-1) {
         next unless $cols->[$i] ~~ $fcols;
         $w += $fcol_lpads->[$i] + $fcol_widths->[$i] + $fcol_rpads->[$i];
         if ($i < @$cols-1) {
             $w += 1 if $has_vsep;
         }
     }
     $w += 1 if length($self->get_border_char(3, 2));
     $self->{_draw}{table_width}  = $w;
 
     my $h = 0;
     $h += 1 if length($self->get_border_char(0, 0)); 
     $h += $self->{header_tpad} // $self->{header_vpad} //
         $self->{cell_tpad} // $self->{cell_vpad};
     $h += $self->{_draw}{header_height} // 0;
     $h += $self->{header_bpad} // $self->{header_vpad} //
         $self->{cell_bpad} // $self->{cell_vpad};
     $h += 1 if length($self->get_border_char(2, 0));
     for my $i (0..@$frows-1) {
         $h += ($frow_tpads->[$i] // 0) +
             ($frow_heights->[$i] // 0) +
                 ($frow_bpads->[$i] // 0);
         $h += 1 if $self->_should_draw_row_separator($i);
     }
     $h += 1 if length($self->get_border_char(5, 0));
     $self->{_draw}{table_height}  = $h;
 }
 
 sub _adjust_column_widths {
     my $self = shift;
 
 
     my $fcols = $self->{_draw}{fcols};
     my $frows = $self->{_draw}{frows};
     my $fcol_setwidths = $self->{_draw}{fcol_setwidths};
     my $fcol_detect    = $self->{_draw}{fcol_detect};
     my $fcol_widths    = $self->{_draw}{fcol_widths};
     my %acols;
     my %origw;
     for my $i (0..@$fcols-1) {
         my $ci = $self->_colnum($fcols->[$i]);
         next if defined($fcol_setwidths->[$ci]) && $fcol_setwidths->[$ci]>0;
         next if $fcol_widths->[$ci] < 30;
         next unless $self->get_eff_column_style($ci, 'wrap') //
             $self->{column_wrap} // $fcol_detect->[$ci]{wrap};
         $acols{$ci}++;
         $origw{$ci} = $fcol_widths->[$ci];
     }
     return 0 unless %acols;
 
     my $termw = $self->term_width;
     return 0 unless $termw > 0;
     my $excess = $self->{_draw}{table_width} - $termw;
     return 0 unless $excess > 0;
 
     my $w = 0; 
     $w += $fcol_widths->[$_] for keys %acols;
     return 0 unless $w > 0;
     my $reduced = 0;
   REDUCE:
     while (1) {
         my $has_reduced;
         for my $ci (keys %acols) {
             last REDUCE if $reduced >= $excess;
             if ($fcol_widths->[$ci] > 30) {
                 $fcol_widths->[$ci]--;
                 $reduced++;
                 $has_reduced++;
             }
         }
         last if !$has_reduced;
     }
 
     for my $ci (keys %acols) {
         $fcol_setwidths->[$ci] = $fcol_widths->[$ci];
         $fcol_widths->[$ci] = 0; 
     }
 
     for my $ci (keys %acols) {
         next unless $origw{$ci} != $fcol_widths->[$ci];
         for (0..@$frows-1) {
             $frows->[$_][$ci] = $self->{_func_wrap}->(
                 $frows->[$_][$ci], $fcol_setwidths->[$ci]);
         }
     }
 
     $self->_calc_row_widths_heights;
     $self->_calc_table_width_height;
     1;
 }
 
 sub _prepare_draw {
     my $self = shift;
 
     $self->{_draw} = {};
 
     $self->_read_style_envs;
     $self->_calc_fcols;
     $self->_calc_header_height;
     $self->_calc_frows;
     $self->_detect_column_types;
     $self->_apply_column_formats;
     $self->_apply_cell_formats;
     $self->_wrap_wrappable_columns;
     $self->_calc_row_widths_heights;
     $self->_calc_table_width_height;
     $self->_adjust_column_widths;
 }
 
 sub draw_str {
     my $self = shift;
 
     for (@_) {
         my $num_nl = 0;
         $num_nl++ while /\r?\n/og;
         push @{$self->{_draw}{buf}}, $_;
         $self->{_draw}{y} += $num_nl;
     }
     $self;
 }
 
 sub draw_theme_color {
     my $self = shift;
     my $c = $self->get_theme_color_as_ansi(@_);
     $self->draw_str($c) if length($c);
 }
 
 sub get_color_reset {
     my $self = shift;
     return "" if $self->{color_theme}{no_color};
     "\e[0m";
 }
 
 sub draw_color_reset {
     my $self = shift;
     my $c = $self->get_color_reset;
     $self->draw_str($c) if length($c);
 }
 
 sub draw_border_char {
     my $self = shift;
     my $args = shift if ref($_[0]) eq 'HASH';
 
     $self->draw_str($self->{_draw}{set_line_draw_mode});
     while (my ($y, $x, $n) = splice @_, 0, 3) {
         $n //= 1;
         if (!$self->{use_color}) {
         } elsif ($args) {
             $self->draw_theme_color('border',
                                     {border=>[$y, $x, $n], %$args});
         } else {
             $self->draw_theme_color('border',
                                     {border=>[$y, $x, $n]});
         }
         $self->draw_str($self->get_border_char($y, $x, $n));
         $self->draw_color_reset;
     }
     $self->draw_str($self->{_draw}{reset_line_draw_mode});
 }
 
 sub _should_draw_row_separator {
     my ($self, $i) = @_;
 
     return $i < @{$self->{_draw}{frows}}-1 &&
         (($self->{show_row_separator}==2 && $i~~$self->{_draw}{frow_separators})
              || $self->{show_row_separator}==1);
 }
 
 sub _get_cell_lines {
     my $self = shift;
     my ($text, $width, $height, $align, $valign,
         $lpad, $rpad, $tpad, $bpad, $color) = @_;
 
     my @lines;
     push @lines, "" for 1..$tpad;
     my @dlines = split(/\r?\n/, $text);
     @dlines = ("") unless @dlines;
     my ($la, $lb);
     $valign //= 'top';
     if ($valign =~ /^[Bb]/o) { 
         $la = $height-@dlines;
         $lb = 0;
     } elsif ($valign =~ /^[MmCc]/o) { 
         $la = int(($height-@dlines)/2);
         $lb = $height-@dlines-$la;
     } else { 
         $la = 0;
         $lb = $height-@dlines;
     }
     push @lines, "" for 1..$la;
     push @lines, @dlines;
     push @lines, "" for 1..$lb;
     push @lines, "" for 1..$bpad;
 
     $align //= 'left';
     my $pad = $align =~ /^[Ll]/o ? "right" :
         ($align =~ /^[Rr]/o ? "left" : "center");
 
     for (@lines) {
         $_ = (" "x$lpad) . $self->{_func_pad}->($_, $width, $pad, " ", 1) . (" "x$rpad);
         if ($self->{use_color}) {
             s/\e\[0m(?=.)/\e[0m$color/g if length($color);
             $_ = $color . $_;
         }
     }
 
     \@lines;
 }
 
 sub _get_header_cell_lines {
     my ($self, $i) = @_;
 
     my $ct = $self->{color_theme};
 
     my $fgcolor;
     if (defined $self->{header_fgcolor}) {
         $fgcolor = $self->theme_color_to_ansi($self->{header_fgcolor});
     } elsif (defined $self->{cell_fgcolor}) {
         $fgcolor = $self->theme_color_to_ansi($self->{cell_fgcolor});
     } elsif (defined $ct->{colors}{header}) {
         $fgcolor = $self->get_theme_color_as_ansi('header');
     } elsif (defined $ct->{colors}{cell}) {
         $fgcolor = $self->get_theme_color_as_ansi('cell');
     } else {
         $fgcolor = "";
     }
 
     my $bgcolor;
     if (defined $self->{header_bgcolor}) {
         $bgcolor = $self->theme_color_to_ansi($self->{header_bgcolor},
                                               undef, 1);
     } elsif (defined $self->{cell_bgcolor}) {
         $bgcolor = $self->theme_color_to_ansi($self->{cell_bgcolor},
                                               undef, 1);
     } elsif (defined $self->{_draw}{fcol_detect}[$i]{bgcolor}) {
         $fgcolor = $self->theme_color_to_ansi($self->{_draw}{fcol_detect}[$i]{bgcolor},
                                               undef, 1);
     } elsif (defined $ct->{colors}{header_bg}) {
         $bgcolor = $self->get_theme_color_as_ansi('header_bg');
     } elsif (defined $ct->{colors}{cell_bg}) {
         $bgcolor = $self->get_theme_color_as_ansi('cell_bg');
     } else {
         $bgcolor = "";
     }
 
     my $align =
         $self->{header_align} //
             $self->{cell_align} //
                 $self->{_draw}{fcol_detect}[$i]{align} //
                     'left';
     my $valign =
         $self->{header_valign} //
             $self->{cell_valign} //
                 $self->{_draw}{fcol_detect}[$i]{valign} //
                     'top';
 
     my $lpad = $self->{_draw}{fcol_lpads}[$i];
     my $rpad = $self->{_draw}{fcol_rpads}[$i];
     my $tpad = $self->{header_tpad} // $self->{header_vpad} // 0;
     my $bpad = $self->{header_bpad} // $self->{header_vpad} // 0;
 
     my $res = $self->_get_cell_lines(
         $self->{columns}[$i],            
         $self->{_draw}{fcol_widths}[$i], 
         $self->{_draw}{header_height},   
         $align, $valign,                 
         $lpad, $rpad, $tpad, $bpad,      
         $fgcolor . $bgcolor);
     $res;
 }
 
 sub _get_data_cell_lines {
     my ($self, $y, $x) = @_;
 
     my $ct   = $self->{color_theme};
     my $oy   = $self->{_draw}{frow_orig_indices}[$y];
     my $cell = $self->{_draw}{frows}[$y][$x];
     my $args = {row_num=>$y, col_num=>$x, data=>$cell,
                 orig_data=>$self->{rows}[$oy][$x]};
 
     my $tmp;
     my $fgcolor;
     if (defined ($tmp = $self->get_eff_cell_style($oy, $x, 'fgcolor'))) {
         $fgcolor = $self->theme_color_to_ansi($tmp, $args);
     } elsif (defined ($tmp = $self->get_eff_row_style($oy, 'fgcolor'))) {
         $fgcolor = $self->theme_color_to_ansi($tmp, $args);
     } elsif (defined ($tmp = $self->get_eff_column_style($x, 'fgcolor'))) {
         $fgcolor = $self->theme_color_to_ansi($tmp, $args);
     } elsif (defined ($tmp = $self->{cell_fgcolor})) {
         $fgcolor = $self->theme_color_to_ansi($tmp, $args);
     } elsif (defined ($tmp = $self->{_draw}{fcol_detect}[$x]{fgcolor})) {
         $fgcolor = $self->theme_color_to_ansi($tmp, $args);
     } elsif (defined $ct->{colors}{cell}) {
         $fgcolor = $self->get_theme_color_as_ansi('cell', $args);
     } else {
         $fgcolor = "";
     }
 
     my $bgcolor;
     if (defined ($tmp = $self->get_eff_cell_style($oy, $x, 'bgcolor'))) {
         $bgcolor = $self->theme_color_to_ansi($tmp, $args, 1);
     } elsif (defined ($tmp = $self->get_eff_row_style($oy, 'bgcolor'))) {
         $bgcolor = $self->theme_color_to_ansi($tmp, $args, 1);
     } elsif (defined ($tmp = $self->get_eff_column_style($x, 'bgcolor'))) {
         $bgcolor = $self->theme_color_to_ansi($tmp, $args, 1);
     } elsif (defined ($tmp = $self->{cell_bgcolor})) {
         $bgcolor = $self->theme_color_to_ansi($tmp, $args, 1);
     } elsif (defined ($tmp = $self->{_draw}{fcol_detect}[$x]{bgcolor})) {
         $bgcolor = $self->theme_color_to_ansi($tmp, $args, 1);
     } elsif (defined $ct->{colors}{cell_bg}) {
         $bgcolor = $self->get_theme_color_as_ansi('cell_bg', $args);
     } else {
         $bgcolor = "";
     }
 
     my $align =
         $self->get_eff_cell_style($oy, $x, 'align') //
             $self->get_eff_row_style($oy, 'align') //
                 $self->get_eff_column_style($x, 'align') //
                     $self->{cell_align} //
                         $self->{_draw}{fcol_detect}[$x]{align} //
                             'left';
     my $valign =
         $self->get_eff_cell_style($oy, $x, 'valign') //
             $self->get_eff_row_style($oy, 'valign') //
                 $self->get_eff_column_style($x, 'valign') //
                     $self->{cell_valign} //
                         $self->{_draw}{fcol_detect}[$x]{valign} //
                             'top';
 
     my $lpad = $self->{_draw}{fcol_lpads}[$x];
     my $rpad = $self->{_draw}{fcol_rpads}[$x];
     my $tpad = $self->{_draw}{frow_tpads}[$y];
     my $bpad = $self->{_draw}{frow_bpads}[$y];
 
     my $res = $self->_get_cell_lines(
         $cell,                            
         $self->{_draw}{fcol_widths}[$x],  
         $self->{_draw}{frow_heights}[$y], 
         $align, $valign,                  
         $lpad, $rpad, $tpad, $bpad,       
         $fgcolor . $bgcolor);
     $res;
 }
 
 sub draw {
     my ($self) = @_;
 
     $self->_prepare_draw;
 
     $self->{_draw}{buf} = []; 
     $self->{_draw}{y} = 0; 
 
     {
         my $bs = $self->{border_style};
         $self->{_draw}{set_line_draw_mode}   = $bs->{box_chars} ? "\e(0" : "";
         $self->{_draw}{reset_line_draw_mode} = $bs->{box_chars} ? "\e(B" : "";
     }
 
     my $cols  = $self->{columns};
     my $fcols = $self->{_draw}{fcols};
     my $frows = $self->{_draw}{frows};
     my $frow_heights    = $self->{_draw}{frow_heights};
     my $frow_tpads      = $self->{_draw}{frow_tpads};
     my $frow_bpads      = $self->{_draw}{frow_bpads};
     my $fcol_lpads      = $self->{_draw}{fcol_lpads};
     my $fcol_rpads      = $self->{_draw}{fcol_rpads};
     my $fcol_widths     = $self->{_draw}{fcol_widths};
 
     {
         last unless length($self->get_border_char(0, 0));
         my @b;
         push @b, 0, 0, 1;
         for my $i (0..@$fcols-1) {
             my $ci = $self->_colnum($fcols->[$i]);
             push @b, 0, 1,
                 $fcol_lpads->[$ci] + $fcol_widths->[$ci] + $fcol_rpads->[$ci];
             push @b, 0, 2, 1 if $i < @$fcols-1;
         }
         push @b, 0, 3, 1;
         $self->draw_border_char(@b);
         $self->draw_str("\n");
     }
 
     if ($self->{show_header}) {
         my %seen;
         my $hcell_lines = []; 
         if (@$fcols) {
             for my $i (0..@$fcols-1) {
                 my $ci = $self->_colnum($fcols->[$i]);
                 if (defined($seen{$i})) {
                     $hcell_lines->[$i] = $hcell_lines->[$seen{$i}];
                 }
                 $seen{$i} = $ci;
                 $hcell_lines->[$i] = $self->_get_header_cell_lines($ci);
             }
         } else {
             $hcell_lines->[0] = [""];
         }
         for my $l (0..@{ $hcell_lines->[0] }-1) {
             $self->draw_border_char(1, 0);
             for my $i (0..@$fcols-1) {
                 $self->draw_str($hcell_lines->[$i][$l]);
                 $self->draw_color_reset;
                 $self->draw_border_char(1, 1) unless $i == @$fcols-1;
             }
             $self->draw_border_char(1, 2);
             $self->draw_str("\n");
         }
     }
 
     if ($self->{show_header} && length($self->get_border_char(2, 0))) {
         my @b;
         push @b, 2, 0, 1;
         for my $i (0..@$fcols-1) {
             my $ci = $self->_colnum($fcols->[$i]);
             push @b, 2, 1,
                 $fcol_lpads->[$ci] + $fcol_widths->[$ci] + $fcol_rpads->[$ci];
             push @b, 2, 2, 1 unless $i==@$fcols-1;
         }
         push @b, 2, 3, 1;
         $self->draw_border_char(@b);
         $self->draw_str("\n");
     }
 
     {
         for my $r (0..@$frows-1) {
             my $dcell_lines = []; 
             my %seen;
             if (@$fcols) {
                 for my $i (0..@$fcols-1) {
                     my $ci = $self->_colnum($fcols->[$i]);
                     if (defined($seen{$i})) {
                         $dcell_lines->[$i] = $dcell_lines->[$seen{$i}];
                     }
                     $seen{$i} = $ci;
                     $dcell_lines->[$i] = $self->_get_data_cell_lines($r, $ci);
                 }
             } else {
                 $dcell_lines->[0] = [" "];
             }
             for my $l (0..@{ $dcell_lines->[0] }-1) {
                 $self->draw_border_char({row_num=>$r}, 3, 0);
                 for my $i (0..@$fcols-1) {
                     $self->draw_str($dcell_lines->[$i][$l]);
                     $self->draw_color_reset;
                     $self->draw_border_char({row_num=>$r}, 3, 1)
                         unless $i == @$fcols-1;
                 }
                 $self->draw_border_char({row_num=>$r}, 3, 2);
                 $self->draw_str("\n");
             }
 
             if ($self->_should_draw_row_separator($r)) {
                 my @b;
                 push @b, 4, 0, 1;
                 for my $i (0..@$fcols-1) {
                     my $ci = $self->_colnum($fcols->[$i]);
                     push @b, 4, 1,
                         $fcol_lpads->[$ci] + $fcol_widths->[$ci] +
                             $fcol_rpads->[$ci];
                     push @b, 4, $i==@$fcols-1 ? 3:2, 1;
                 }
                 $self->draw_border_char({row_num=>$r}, @b);
                 $self->draw_str("\n");
             }
         } 
     }
 
     {
         last unless length($self->get_border_char(5, 0));
         my @b;
         push @b, 5, 0, 1;
         for my $i (0..@$fcols-1) {
             my $ci = $self->_colnum($fcols->[$i]);
             push @b, 5, 1,
                 $fcol_lpads->[$ci] + $fcol_widths->[$ci] + $fcol_rpads->[$ci];
             push @b, 5, 2, 1 unless $i == @$fcols-1;
         }
         push @b, 5, 3, 1;
         $self->draw_border_char(@b);
         $self->draw_str("\n");
     }
 
     join "", @{$self->{_draw}{buf}};
 }
 
 1;
 
 __END__
 
### Text/ANSITable/BorderStyle/Default.pm ###
 package Text::ANSITable::BorderStyle::Default;
 
 our $DATE = '2015-10-22'; 
 our $VERSION = '0.46'; 
 
 use 5.010;
 use strict;
 use utf8;
 use warnings;
 
 our %border_styles = (
 
 
     none_ascii => {
         summary => 'No border',
         chars => [
             ['','','',''],     
             ['','',''],        
             ['','','',''],     
             ['','',''],        
             [' ','-','-',' '], 
             ['','','',''],     
         ],
     },
 
     none_boxchar => {
         summary => 'No border',
         chars => [
             ['','','',''],     
             ['','',''],        
             ['','','',''],     
             ['','',''],        
             ['','q','q',''],   
             ['','','',''],     
         ],
         box_chars => 1,
     },
 
     none_utf8 => {
         summary => 'No border',
         chars => [
             ['','','',''],     
             ['','',''],        
             ['','','',''],     
             ['','',''],        
             ['','─','─',''],   
             ['','','',''],     
         ],
         utf8 => 1,
     },
 
 
 
     space_ascii => {
         summary => 'Space as border',
         chars => [
             [' ',' ',' ',' '], 
             [' ',' ',' '],     
             [' ',' ',' ',' '], 
             [' ',' ',' '],     
             [' ','-','-',' '], 
             [' ',' ',' ',' '], 
         ],
     },
 
     space_boxchar => {
         summary => 'Space as border',
         chars => [
             [' ',' ',' ',' '], 
             [' ',' ',' '],     
             [' ',' ',' ',' '], 
             [' ',' ',' '],     
             [' ','q','q',' '], 
             [' ',' ',' ',' '], 
         ],
         box_chars => 1,
     },
 
     space_utf8 => {
         summary => 'Space as border',
         chars => [
             [' ',' ',' ',' '], 
             [' ',' ',' '],     
             [' ',' ',' ',' '], 
             [' ',' ',' '],     
             [' ','─','─',' '], 
             [' ',' ',' ',' '], 
         ],
         utf8 => 1,
     },
 
     spacei_ascii => {
         summary => 'Space, inner-only',
         chars => [
             ['','','',''],   
             ['',' ',''],     
             ['',' ',' ',''], 
             ['',' ',''],     
             ['','-','-',''], 
             ['','','',''],   
         ],
     },
 
     spacei_boxchar => {
         summary => 'Space, inner-only',
         chars => [
             ['','','',''],   
             ['',' ',''],     
             ['',' ',' ',''], 
             ['',' ',''],     
             ['','q','q',''], 
             ['','','',''],   
         ],
         box_chars => 1,
     },
 
     spacei_utf8 => {
         summary => 'Space, inner-only',
         chars => [
             ['','','',''],   
             ['',' ',''],     
             ['',' ',' ',''], 
             ['',' ',''],     
             ['','─','─',''], 
             ['','','',''],   
         ],
         utf8 => 1,
     },
 
 
     single_ascii => {
         summary => 'Single',
         chars => [
             ['.','-','+','.'], 
             ['|','|','|'],     
             ['+','-','+','+'], 
             ['|','|','|'],     
             ['+','-','+','+'], 
             ['`','-','+',"'"], 
         ],
     },
 
     single_boxchar => {
         summary => 'Single',
         chars => [
             ['l','q','w','k'], 
             ['x','x','x'],     
             ['t','q','n','u'], 
             ['x','x','x'],     
             ['t','q','n','u'], 
             ['m','q','v','j'], 
         ],
         box_chars => 1,
     },
 
     single_utf8 => {
         summary => 'Single',
         chars => [
             ['┌','─','┬','┐'], 
             ['│','│','│'],     
             ['├','─','┼','┤'], 
             ['│','│','│'],     
             ['├','─','┼','┤'], 
             ['└','─','┴','┘'], 
         ],
         utf8 => 1,
     },
 
 
 
     singleh_ascii => {
         summary => 'Single, horizontal only',
         chars => [
             ['-','-','-','-'], 
             [' ',' ',' '],     
             ['-','-','-','-'], 
             [' ',' ',' '],     
             ['-','-','-','-'], 
             ['-','-','-','-'], 
         ],
     },
 
     singleh_boxchar => {
         summary => 'Single, horizontal only',
         chars => [
             ['q','q','q','q'], 
             [' ',' ',' '],     
             ['q','q','q','q'], 
             [' ',' ',' '],     
             ['q','q','q','q'], 
             ['q','q','q','q'], 
         ],
         box_chars => 1,
     },
 
     singleh_utf8 => {
         summary => 'Single, horizontal only',
         chars => [
             ['─','─','─','─'], 
             [' ',' ',' '],     
             ['─','─','─','─'], 
             [' ',' ',' '],     
             ['─','─','─','─'], 
             ['─','─','─','─'], 
         ],
         utf8 => 1,
     },
 
 
 
     singlev_ascii => {
         summary => 'Single border, only vertical',
         chars => [
             ['|',' ','|','|'], 
             ['|','|','|'],     
             ['|',' ','|','|'], 
             ['|','|','|'],     
             ['|','-','|','|'], 
             ['|',' ','|','|'], 
         ],
     },
 
     singlev_boxchar => {
         summary => 'Single, vertical only',
         chars => [
             ['x',' ','x','x'], 
             ['x','x','x'],     
             ['x',' ','x','x'], 
             ['x','x','x'],     
             ['x','q','x','x'], 
             ['x',' ','x','x'], 
         ],
         box_chars => 1,
     },
 
     singlev_utf8 => {
         summary => 'Single, vertical only',
         chars => [
             ['│',' ','│','│'], 
             ['│','│','│'],     
             ['│',' ','│','│'], 
             ['│','│','│'],     
             ['│','─','│','│'], 
             ['│',' ','│','│'], 
         ],
         utf8 => 1,
     },
 
 
 
     singlei_ascii => {
         summary => 'Single, inner only (like in psql command-line client)',
         chars => [
             ['','','',''],     
             [' ','|',' '],     
             [' ','-','+',' '], 
             [' ','|',' '],     
             [' ','-','+',' '], 
             ['','','',''],     
         ],
     },
 
     singlei_boxchar => {
         summary => 'Single, inner only (like in psql command-line client)',
         chars => [
             ['','','',''],     
             [' ','x',' '],     
             [' ','q','n',' '], 
             [' ','x',' '],     
             [' ','q','n',' '], 
             ['','','',''],     
         ],
         box_chars => 1,
     },
 
     singlei_utf8 => {
         summary => 'Single, inner only (like in psql command-line client)',
         chars => [
             ['','','',''],     
             [' ','│',' '],     
             [' ','─','┼',' '], 
             [' ','│',' '],     
             [' ','─','┼',' '], 
             ['','','',''],     
         ],
         utf8 => 1,
     },
 
 
 
     singleo_ascii => {
         summary => 'Single, outer only',
         chars => [
             ['.','-','-','.'], 
             ['|',' ','|'],     
             ['|',' ',' ','|'], 
             ['|',' ','|'],     
             ['+','-','-','+'], 
             ['`','-','-',"'"], 
         ],
     },
 
     singleo_boxchar => {
         summary => 'Single, outer only',
         chars => [
             ['l','q','q','k'], 
             ['x',' ','x'],     
             ['x',' ',' ','x'], 
             ['x',' ','x'],     
             ['t','q','q','u'], 
             ['m','q','q','j'], 
         ],
         box_chars => 1,
     },
 
     singleo_utf8 => {
         summary => 'Single, outer only',
         chars => [
             ['┌','─','─','┐'], 
             ['│',' ','│'],     
             ['│',' ',' ','│'], 
             ['│',' ','│'],     
             ['├','─','─','┤'], 
             ['└','─','─','┘'], 
         ],
         utf8 => 1,
     },
 
 
 
     csingle => {
         summary => 'Curved single',
         chars => [
             ['╭','─','┬','╮'], 
             ['│','│','│'],     
             ['├','─','┼','┤'], 
             ['│','│','│'],     
             ['├','─','┼','┤'], 
             ['╰','─','┴','╯'], 
         ],
         utf8 => 1,
     },
 
 
 
     bold => {
         summary => 'Bold',
         chars => [
             ['┏','━','┳','┓'], 
             ['┃','┃','┃'],     
             ['┣','━','╋','┫'], 
             ['┃','┃','┃'],     
             ['┣','━','╋','┫'], 
             ['┗','━','┻','┛'], 
         ],
         utf8 => 1,
     },
 
 
 
 
 
 
 
     double => {
         summary => 'Double',
         chars => [
             ['╔','═','╦','╗'], 
             ['║','║','║'],     
             ['╠','═','╬','╣'], 
             ['║','║','║'],     
             ['╠','═','╬','╣'], 
             ['╚','═','╩','╝'], 
         ],
         utf8 => 1,
     },
 
 
 
     brick => {
         summary => 'Single, bold on bottom right to give illusion of depth',
         chars => [
             ['┌','─','┬','┒'], 
             ['│','│','┃'],     
             ['├','─','┼','┨'], 
             ['│','│','┃'],     
             ['├','─','┼','┨'], 
             ['┕','━','┷','┛'], 
         ],
         utf8 => 1,
     },
 
     bricko => {
         summary => 'Single, outer only, '.
             'bold on bottom right to give illusion of depth',
         chars => [
             ['┌','─','─','┒'], 
             ['│',' ','┃'],     
             ['│',' ',' ','┃'], 
             ['│',' ','┃'],     
             ['├','─','─','┨'], 
             ['┕','━','━','┛'], 
         ],
         utf8 => 1,
     },
 
 );
 
 1;
 
 __END__
 
### Text/ANSITable/ColorTheme/Default.pm ###
 package Text::ANSITable::ColorTheme::Default;
 
 our $DATE = '2015-10-22'; 
 our $VERSION = '0.46'; 
 
 use 5.010;
 use strict;
 use warnings;
 
 use Color::RGB::Util qw(mix_2_rgb_colors);
 use Function::Fallback::CoreOrPP qw(clone);
 
 our %color_themes = (
 
     no_color => {
         v => 1.1,
         summary => 'Special theme that means no color',
         colors => {
         },
         no_color => 1,
     },
 
 
     default_gradation => {
         v => 1.1,
         summary => 'Default (for terminal with black background)',
         description => <<'_',
 
 Border color has gradation from top to bottom. Accept arguments C<border1> and
 C<border2> to set first (top) and second (bottom) foreground RGB colors. Colors
 will fade from the top color to bottom color. Also accept C<border1_bg> and
 C<border2_bg> to set background RGB colors.
 
 _
         colors => {
             border      => sub {
                 my ($self, %args) = @_;
 
                 my $pct = ($self->{_draw}{y}+1) / $self->{_draw}{table_height};
 
                 my $rgbf1 = $self->{color_theme_args}{border1} // $self->{color_theme}{data}{default_border1} // 'ffffff';
                 my $rgbf2 = $self->{color_theme_args}{border2} // $self->{color_theme}{data}{default_border2} // '444444';
                 my $rgbf  = mix_2_rgb_colors($rgbf1, $rgbf2, $pct);
 
                 my $rgbb1 = $self->{color_theme_args}{border1_bg};
                 my $rgbb2 = $self->{color_theme_args}{border2_bg};
                 my $rgbb;
                 if ($rgbb1 && $rgbb2) {
                     $rgbb = mix_2_rgb_colors($rgbb1, $rgbb2, $pct);
                 }
 
                 {fg=>$rgbf, bg=>$rgbb};
             },
 
             header      => '808080',
             header_bg   => undef,
             cell        => undef,
             cell_bg     => undef,
 
             num_data    => '66ffff',
             str_data    => undef,
             date_data   => 'aaaa00',
             bool_data   => sub {
                 my ($self, %args) = @_;
 
                 $args{orig_data} ? '00ff00' : 'ff0000';
             },
         },
     },
 
 );
 
 {
     my $ct = clone($color_themes{default_gradation});
     $ct->{summary} = 'Default (for terminal with white background)';
     $ct->{colors}{header_bg} = 'cccccc';
     $ct->{data}{default_border1} = '000000';
     $ct->{data}{default_border2} = 'cccccc';
     $ct->{colors}{num_data}  = '006666';
     $ct->{colors}{date_data} = '666600';
     $ct->{colors}{bool_data} = sub {
         my ($self, %args) = @_;
         $args{orig_data} ? '00cc00' : 'cc0000';
     };
     $color_themes{default_gradation_whitebg} = $ct;
 }
 
 
 {
     my $ct = clone($color_themes{default_gradation});
     $ct->{colors}{border} = '666666';
     delete $ct->{description};
     $color_themes{default_nogradation} = $ct;
 }
 
 {
     my $ct = clone($color_themes{default_gradation_whitebg});
     $ct->{colors}{border} = '666666';
     delete $ct->{description};
     $color_themes{default_nogradation_whitebg} = $ct;
 }
 
 1;
 
 __END__
 
### Text/ANSITable/StyleSet/AltRow.pm ###
 package Text::ANSITable::StyleSet::AltRow;
 
 our $DATE = '2015-10-22'; 
 our $VERSION = '0.46'; 
 
 use 5.010;
 use Moo;
 use namespace::clean;
 
 has odd_bgcolor  => (is => 'rw');
 has even_bgcolor => (is => 'rw');
 has odd_fgcolor  => (is => 'rw');
 has even_fgcolor => (is => 'rw');
 
 sub summary {
     "Set different foreground and/or background color for odd/even rows";
 }
 
 sub apply {
     my ($self, $table) = @_;
 
     $table->add_cond_row_style(
         sub {
             my ($t, %args) = @_;
             my %styles;
             if ($_ % 2 == 0) {
                 $styles{bgcolor} = $self->odd_bgcolor
                     if defined $self->odd_bgcolor;
                 $styles{fgcolor}=$self->odd_fgcolor
                     if defined $self->odd_fgcolor;
             } else {
                 $styles{bgcolor} = $self->even_bgcolor
                     if defined $self->even_bgcolor;
                 $styles{fgcolor} = $self->even_fgcolor
                     if defined $self->even_fgcolor;
             }
             \%styles;
         },
     );
 }
 
 1;
 
 
 __END__
 
### Text/Table/Tiny.pm ###
 use strict;
 use warnings;
 package Text::Table::Tiny;
 use List::Util qw();
 
 
 
 our $COLUMN_SEPARATOR = '|';
 our $ROW_SEPARATOR = '-';
 our $CORNER_MARKER = '+';
 our $HEADER_ROW_SEPARATOR = '=';
 our $HEADER_CORNER_MARKER = 'O';
 
 sub table {
 
     my %params = @_;
     my $rows = $params{rows} or die "Must provide rows!";
 
     my $widths = _maxwidths($rows);
     my $max_index = _max_array_index($rows);
 
     my $format = _get_format($widths);
     my $row_sep = _get_row_separator($widths);
     my $head_row_sep = _get_header_row_separator($widths);
 
     my @table;
     push @table, $row_sep;
 
     my $data_begins = 0;
     if ( $params{header_row} ) {
         my $header_row = $rows->[0];
 	$data_begins++;
         push @table, sprintf(
 	    $format, 
 	    map { defined($header_row->[$_]) ? $header_row->[$_] : '' } (0..$max_index)
 	);
         push @table, $params{separate_rows} ? $head_row_sep : $row_sep;
     }
 
     foreach my $row ( @{ $rows }[$data_begins..$#$rows] ) {
         push @table, sprintf(
 	    $format, 
 	    map { defined($row->[$_]) ? $row->[$_] : '' } (0..$max_index)
 	);
         push @table, $row_sep if $params{separate_rows};
     }
 
     push @table, $row_sep unless $params{separate_rows};
     return join("\n",grep {$_} @table);
 }
 
 sub _get_cols_and_rows ($) {
     my $rows = shift;
     return ( List::Util::max( map { scalar @$_ } @$rows), scalar @$rows);
 }
 
 sub _maxwidths {
     my $rows = shift;
     my $max_index = _max_array_index($rows);
     my $widths = [];
     for my $i (0..$max_index) {
         my $max = List::Util::max(map {defined $$_[$i] ? length($$_[$i]) : 0} @$rows);
         push @$widths, $max;
     }
     return $widths;
 }
 
 sub _max_array_index {
     my $rows = shift;
     return List::Util::max( map { $#$_ } @$rows );
 }
 
 sub _get_format {
     my $widths = shift;
     return "$COLUMN_SEPARATOR ".join(" $COLUMN_SEPARATOR ",map { "%-${_}s" } @$widths)." $COLUMN_SEPARATOR";
 }
 
 sub _get_row_separator {
     my $widths = shift;
     return "$CORNER_MARKER$ROW_SEPARATOR".join("$ROW_SEPARATOR$CORNER_MARKER$ROW_SEPARATOR",map { $ROW_SEPARATOR x $_ } @$widths)."$ROW_SEPARATOR$CORNER_MARKER";
 }
 
 sub _get_header_row_separator {
     my $widths = shift;
     return "$HEADER_CORNER_MARKER$HEADER_ROW_SEPARATOR".join("$HEADER_ROW_SEPARATOR$HEADER_CORNER_MARKER$HEADER_ROW_SEPARATOR",map { $HEADER_ROW_SEPARATOR x $_ } @$widths)."$HEADER_ROW_SEPARATOR$HEADER_CORNER_MARKER";
 }
 
 1;
 
 __END__
 
### Text/sprintfn.pm ###
 package Text::sprintfn;
 
 use 5.010001;
 use strict;
 use warnings;
 
 require Exporter;
 our @ISA       = qw(Exporter);
 our @EXPORT    = qw(sprintfn printfn);
 
 our $VERSION = '0.08'; 
 
 our $distance  = 10;
 
 my  $re1   = qr/[^)]+/s;
 my  $re2   = qr{(?<fmt>
                     %
                        (?<pi> \d+\$ | \((?<npi>$re1)\)\$?)?
                        (?<flags> [ +0#-]+)?
                        (?<vflag> \*?[v])?
                        (?<width> -?\d+ |
                            \*\d+\$? |
                            \((?<nwidth>$re1)\))?
                        (?<dot>\.?)
                        (?<prec>
                            (?: \d+ | \* |
                            \((?<nprec>$re1)\) ) ) ?
                        (?<conv> [%csduoxefgXEGbBpniDUOF])
                    )}x;
 our $regex = qr{($re2|%|[^%]+)}s;
 
 if (1) {
     $regex = qr{( #all=1
                     ( #fmt=2
                         %
                         (#pi=3
                             \d+\$ | \(
                             (#npi=4
                                 [^)]+)\)\$?)?
                         (#flags=5
                             [ +0#-]+)?
                         (#vflag=6
                             \*?[v])?
                         (#width=7
                             -?\d+ |
                             \*\d+\$? |
                             \((#nwidth=8
                                 [^)]+)\))?
                         (#dot=9
                             \.?)
                         (#prec=10
                             (?: \d+ | \* |
                                 \((#nprec=11
                                     [^)]+)\) ) ) ?
                         (#conv=12
                             [%csduoxefgXEGbBpniDUOF])
                     ) | % | [^%]+
                 )}xs;
 }
 
 sub sprintfn {
     my ($format, @args) = @_;
 
     my $hash;
     if (ref($args[0]) eq 'HASH') {
         $hash = shift(@args);
     }
     return sprintf($format, @args) if !$hash;
 
     my %indexes; 
     push @args, (undef) x $distance;
 
     $format =~ s{$regex}{
         my ($all, $fmt, $pi, $npi, $flags,
             $vflag, $width, $nwidth, $dot, $prec,
             $nprec, $conv) =
             ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12);
 
         my $res;
         if ($fmt) {
 
             if (defined $npi) {
                 my $i = $indexes{$npi};
                 if (!$i) {
                     $i = @args + 1;
                     push @args, $hash->{$npi};
                     $indexes{$npi} = $i;
                 }
                 $pi = "${i}\$";
             }
 
             if (defined $nwidth) {
                 $width = $hash->{$nwidth};
             }
 
             if (defined $nprec) {
                 $prec = $hash->{$nprec};
             }
 
             $res = join("",
                 grep {defined} (
                     "%",
                     $pi, $flags, $vflag,
                     $width, $dot, $prec, $conv)
                 );
         } else {
             my $i = @args + 1;
             push @args, $all;
             $res = "\%${i}\$s";
         }
         $res;
     }xego;
 
 
     sprintf $format, @args;
 }
 
 sub printfn {
     print sprintfn @_;
 }
 
 1;
 
 __END__
 
### Tie/Cache.pm ###
 #!/usr/local/bin/perl -w
 
 package Tie::Cache;
 use strict;
 use vars qw(
  $VERSION $Debug $STRUCT_SIZE $REF_SIZE
  $BEFORE $AFTER $KEY $VALUE $BYTES $DIRTY
 );
 
 $VERSION = .21;
 $Debug = 0; 
 $STRUCT_SIZE = 240; 
 $REF_SIZE    = 16;
 
 $KEY    = 0;
 $VALUE  = 1;
 $BYTES  = 2;
 $BEFORE = 3;
 $AFTER  = 4;
 $DIRTY  = 5;
 
 
 
 sub TIEHASH {
     my($class, $max_count, $options) = @_;
 
     if(ref($max_count)) {
 	$options = $max_count;
 	$max_count = $options->{MaxCount};
     }
 	
     unless($max_count || $options->{MaxBytes}) {
 	die('you must specify cache size with either MaxBytes or MaxCount');
     }
 
     my $sync = exists($options->{WriteSync}) ? $options->{WriteSync} : 1;
 
     my $self = bless 
       { 
        max_count=> $max_count, 
        
        max_bytes => $options->{MaxBytes},
        
        max_size => $options->{MaxSize} || ($options->{MaxBytes} ? (int($options->{MaxBytes}/10) + 1) : 0),
        
        'class'    => $class,
        'subclass' => $class ne 'Tie::Cache' ? 1 : 0,
        
        count=>0,
        bytes=>0,
        
        head=>0, 
        tail=>0, 
        nodes=>{},
        'keys'=>[],
        
        hit => 0,
        miss => 0,
        
        sync => $sync,
        dbg => $options->{Debug} || $Debug
        
        
       }, $class;
     
     if (($self->{max_bytes} && ! $self->{max_size})) {
 	die("MaxSize must be defined when MaxBytes is");
     }
 
     if($self->{max_bytes} and $self->{max_bytes} < 1000) {
 	die("cannot set MaxBytes to under 1000, each raw entry takes $STRUCT_SIZE bytes alone");
     }
 
     if($self->{max_size} && $self->{max_size} < 3) {
 	die("cannot set MaxSize to under 3 bytes, assuming error in config");
     }
 
     $self;
 }
 
 sub write { undef; }
 
 sub read { undef; }
 
 sub FETCH {
     my($self, $key) = @_;
 
     my $node = $self->{nodes}{$key};
     if($node) {
 	$self->{hit}++; 
 
 	if(my $after = $node->[$AFTER]) {
 	    $self->{dbg} > 1 and $self->print("update() node $node to tail of list");
 	    my $before = $after->[$BEFORE] = $node->[$BEFORE];
 	    if($before) {
 		$before->[$AFTER] = $after;
 	    } else {
 		$self->{head} = $after;
 	    }
 
 	    $self->{tail}[$AFTER] = $node;
 	    $node->[$BEFORE] = $self->{tail};
 	    $node->[$AFTER] = undef;
 	    $self->{tail} = $node; 
 	} else {
 	    die("this node is the tail, so something's wrong") 
 		unless($self->{tail} eq $node);
 	}
 
 	$self->print("FETCH [$key, $node->[$VALUE]]") if ($self->{dbg} > 1);
 	$node->[$VALUE];
     } else {
 	$self->{miss}++; 
 
 	my $value;
 	if ($self->{subclass}) {
 	    $self->print("read() for key $key") if $self->{dbg} > 1;
 	    $value = $self->read($key);
 	}
 
 	if(defined $value) {
 	    my $length;
 	    if($self->{max_size}) {
 		$length = &_get_data_length(\$key, \$value);
 		if($length > $self->{max_size}) {
 		    $self->print("direct read() [$key, $value]") if ($self->{dbg} > 1);
 		    return $value;
 		}
 	    }
 	    $node = &create_node($self, \$key, \$value, $length);
 	    &insert($self, $node);
 	    $value;
 	} else {
 	    undef;
 	}
     }
 }
 
 sub STORE {
     my($self, $key, $value) = @_;
     my $node;
 
     $self->print("STORE [$key,$value]") if ($self->{dbg} > 1);
 
     defined($value) || return(undef);
 
     my $length;
     if($self->{max_size}) {
 	$length = &_get_data_length(\$key, \$value);
 	if($length > $self->{max_size}) {
 	    if ($self->{subclass}) {
 		$self->print("direct write() [$key, $value]") if ($self->{dbg} > 1);
 		$self->write($key, $value);
 	    }
 	    return $value;
 	}
     }
 
     if($self->{nodes}{$key}) {
 	$node = &delete($self, $key);
     }
 
     $node = &create_node($self, \$key, \$value, $length);
     &insert($self, $node);
 
     if ($self->{subclass}) {
 	if($self->{sync}) {
 	    $self->print("sync write() [$key, $value]") if $self->{dbg} > 1;
 	    $self->write($key, $value);
 	} else {
 	    $node->[$DIRTY] = 1;
 	}
     }
 
     $value;
 }
 
 sub DELETE {
     my($self, $key) = @_;
 
     $self->print("DELETE $key") if ($self->{dbg} > 1);
     my $node = $self->delete($key);
     $node ? $node->[$VALUE] : undef;
 }
 
 sub CLEAR {
     my($self) = @_;
 
     $self->print("CLEAR CACHE") if ($self->{dbg} > 1);
 
     if($self->{subclass}) {
 	my $flushed = $self->flush();
 	$self->print("FLUSH COUNT $flushed") if ($self->{dbg} > 1);
     }
 
     my $node;
     while($node = $self->{head}) {
 	$self->delete($self->{head}[$KEY]);
     }
 
     1;
 }
 
 sub EXISTS {
     my($self, $key) = @_;
     exists $self->{nodes}{$key};
 }
     
 sub FIRSTKEY {
     my($self) = @_;
 
     $self->{'keys'} = [];
     my $node = $self->{head};
     while($node) {
 	push(@{$self->{'keys'}}, $node->[$KEY]);
 	$node = $node->[$AFTER];
     }
 
     shift @{$self->{'keys'}};
 }
 
 sub NEXTKEY {
     my($self, $lastkey) = @_;
     shift @{$self->{'keys'}};
 }
 
 sub DESTROY {
     my($self) = @_;
 
     if($self->{dbg}) {
 	if($self->{hit} || $self->{miss}) {
 	    $self->{hit_ratio} = 
 		sprintf("%4.3f", $self->{hit} / ($self->{hit} + $self->{miss})); 
 	}
 	$self->print($self->pretty_self());
 	if($self->{dbg} > 1) {
 	    $self->print($self->pretty_chains());
 	}
     }
     
     $self->print("DESTROYING") if $self->{dbg} > 1;
     $self->CLEAR();
     
     1;
 }
 
 
 sub create_node {
     my($self, $key, $value, $length) = @_;
     (defined($$key) && defined($$value)) 
       || die("need more localized data than $$key and $$value");
     
     if (($self->{max_size})) {
 	$length = defined $length ? $length : &_get_data_length($key, $value)
     } else {
 	$length = 0;
     }
     
     my $node = [ $$key, $$value, $length ];
 }
 
 sub _get_data_length {
     my($key, $value) = @_;
     my $length = 0;
     my %refs;
 
     my @data = ($$key, $$value);
     while(my $elem = shift @data) {
 	next if $refs{$elem};
 	$refs{$elem} = 1;
 	if(ref $elem && ref($elem) =~ /^(SCALAR|HASH|ARRAY)$/) {
 	    my $type = $1;
 	    $length += $REF_SIZE; 
 	    if (($type eq 'SCALAR')) {
 		$length += length($$elem);
 	    } elsif (($type eq 'HASH')) {
 		while (my($k,$v) = each %$elem) {
 		    for my $kv($k,$v) {
 			if ((ref $kv)) {
 			    push(@data, $kv);
 			} else {
 			    $length += length($kv);
 			}
 		    }
 		}
 	    } elsif (($type eq 'ARRAY')) {
 		for my $val (@$elem){
 		    if ((ref $val)) {
 			push(@data, $val);
 		    } else {
 			$length += length($val);
 		    }
 		}
 	    }
 	} else {
 	    $length += length($elem);
 	}
     }
 
     $length;
 }
 
 sub insert {
     my($self, $new_node) = @_;
     
     $new_node->[$AFTER] = 0;
     $new_node->[$BEFORE] = $self->{tail};
     $self->print("insert() [$new_node->[$KEY], $new_node->[$VALUE]]") if ($self->{dbg} > 1);
     
     $self->{nodes}{$new_node->[$KEY]} = $new_node;
 
     $self->{count}++;
     $self->{bytes} += $new_node->[$BYTES] + $STRUCT_SIZE;
 
     if($self->{tail}) {
 	$self->{tail}[$AFTER] = $new_node;
     } else {
 	$self->{head} = $new_node;
     }
     $self->{tail} = $new_node;
 
     while(($self->{max_count} && ($self->{count} > $self->{max_count})) ||
 	  ($self->{max_bytes} && ($self->{bytes} > $self->{max_bytes}))) 
     {
 	if($self->{dbg} > 1) {
 	    $self->print("current/max: ".
 			 "bytes ($self->{bytes}/$self->{max_bytes}) ".
 			 "count ($self->{count}/$self->{max_count}) "
 			 );
 	}
 	my $old_node = $self->delete($self->{head}[$KEY]);
 	if ($self->{subclass}) {
 	    if($old_node->[$DIRTY]) {
 		$self->print("dirty write() [$old_node->[$KEY], $old_node->[$VALUE]]") 
 		  if ($self->{dbg} > 1);
 		$self->write($old_node->[$KEY], $old_node->[$VALUE]);
 	    }
 	}
     }
     
     1;
 }
 
 sub delete {
     my($self, $key) = @_;    
     my $node = $self->{nodes}{$key} || return;
 
     $self->print("delete() [$key, $node->[$VALUE]]") if ($self->{dbg} > 1);
 
     my $before = $node->[$BEFORE];
     my $after = $node->[$AFTER];
 
     if($before) {
 	($before->[$AFTER] = $after);
     } else {
 	$self->{head} = $after;
     }
 
     if($after) {
 	($after->[$BEFORE] = $before);
     } else {
 	$self->{tail} = $before;
     }
 
     delete $self->{nodes}{$key};
     $self->{bytes} -= ($node->[$BYTES] + $STRUCT_SIZE);
     $self->{count}--;
     
     $node;
 }
 
 sub flush {
     my $self = shift;
 
     $self->print("FLUSH CACHE") if ($self->{dbg} > 1);
 
     my $node = $self->{head};
     my $flush_count = 0;
     while($node) {
 	if($node->[$DIRTY]) {
 	    $self->print("flush dirty write() [$node->[$KEY], $node->[$VALUE]]") 
 	      if ($self->{dbg} > 1);
 	    $self->write($node->[$KEY], $node->[$VALUE]);
 	    $node->[$DIRTY] = 0;
 	    $flush_count++;
 	}
 	$node = $node->[$AFTER];
     }
 
     $flush_count;
 }
 
 sub print {
     my($self, $msg) = @_;
     print "$self: $msg\n";
 }
 
 sub pretty_self {
     my($self) = @_;
     
     my(@prints);
     for(sort keys %{$self}) { 
 	next unless defined $self->{$_};
 	push(@prints, "$_=>$self->{$_}"); 
     }
 
     "{ " . join(", ", @prints) . " }";
 }
 
 sub pretty_chains {
     my($self) = @_;
     my($str);
     my $k = $self->FIRSTKEY();
 
     $str .= "[head]->";
     my($curr_node) = $self->{head};
     while($curr_node) {
 	$str .= "[$curr_node->[$KEY],$curr_node->[$VALUE]]->";
 	$curr_node = $curr_node->[$AFTER];
     }
     $str .= "[tail]->";
 
     $curr_node = $self->{tail};
     while($curr_node) {
 	$str .= "[$curr_node->[$KEY],$curr_node->[$VALUE]]->";
 	$curr_node = $curr_node->[$BEFORE];
     }
     $str .= "[head]";
 
     $str;
 }
 
 1;
 
 __END__
 
 
 
 
 
 
 
### Tie/IxHash.pm ###
 
 require 5.005;
 
 package Tie::IxHash;
 use strict;
 use integer;
 require Tie::Hash;
 use vars qw/@ISA $VERSION/;
 @ISA = qw(Tie::Hash);
 
 $VERSION = $VERSION = '1.23';
 
 
 sub TIEHASH {
   my($c) = shift;
   my($s) = [];
   $s->[0] = {};   
   $s->[1] = [];   
   $s->[2] = [];   
   $s->[3] = 0;    
 
   bless $s, $c;
 
   $s->Push(@_) if @_;
 
   return $s;
 }
 
 
 sub FETCH {
   my($s, $k) = (shift, shift);
   return exists( $s->[0]{$k} ) ? $s->[2][ $s->[0]{$k} ] : undef;
 }
 
 sub STORE {
   my($s, $k, $v) = (shift, shift, shift);
   
   if (exists $s->[0]{$k}) {
     my($i) = $s->[0]{$k};
     $s->[1][$i] = $k;
     $s->[2][$i] = $v;
     $s->[0]{$k} = $i;
   }
   else {
     push(@{$s->[1]}, $k);
     push(@{$s->[2]}, $v);
     $s->[0]{$k} = $#{$s->[1]};
   }
 }
 
 sub DELETE {
   my($s, $k) = (shift, shift);
 
   if (exists $s->[0]{$k}) {
     my($i) = $s->[0]{$k};
     for ($i+1..$#{$s->[1]}) {    
       $s->[0]{ $s->[1][$_] }--;    
     }
     if ( $i == $s->[3]-1 ) {
       $s->[3]--;
     }
     delete $s->[0]{$k};
     splice @{$s->[1]}, $i, 1;
     return (splice(@{$s->[2]}, $i, 1))[0];
   }
   return undef;
 }
 
 sub EXISTS {
   exists $_[0]->[0]{ $_[1] };
 }
 
 sub FIRSTKEY {
   $_[0][3] = 0;
   &NEXTKEY;
 }
 
 sub NEXTKEY {
   return $_[0][1][ $_[0][3]++ ] if ($_[0][3] <= $#{ $_[0][1] } );
   return undef;
 }
 
 
 
 
 sub new { TIEHASH(@_) }
 
 sub Clear {
   my $s = shift;
   $s->[0] = {};   
   $s->[1] = [];   
   $s->[2] = [];   
   $s->[3] = 0;    
   return;
 }
 
 sub Push {
   my($s) = shift;
   while (@_) {
     $s->STORE(shift, shift);
   }
   return scalar(@{$s->[1]});
 }
 
 sub Push2 {
   my($s) = shift;
   $s->Splice($#{$s->[1]}+1, 0, @_);
   return scalar(@{$s->[1]});
 }
 
 sub Pop {
   my($s) = shift;
   my($k, $v, $i);
   $k = pop(@{$s->[1]});
   $v = pop(@{$s->[2]});
   if (defined $k) {
     delete $s->[0]{$k};
     return ($k, $v);
   }
   return undef;
 }
 
 sub Pop2 {
   return $_[0]->Splice(-1);
 }
 
 sub Shift {
   my($s) = shift;
   my($k, $v, $i);
   $k = shift(@{$s->[1]});
   $v = shift(@{$s->[2]});
   if (defined $k) {
     delete $s->[0]{$k};
     for (keys %{$s->[0]}) {
       $s->[0]{$_}--;
     }
     return ($k, $v);
   }
   return undef;
 }
 
 sub Shift2 {
   return $_[0]->Splice(0, 1);
 }
 
 sub Unshift {
   my($s) = shift;
   my($k, $v, @k, @v, $len, $i);
 
   while (@_) {
     ($k, $v) = (shift, shift);
     if (exists $s->[0]{$k}) {
       $i = $s->[0]{$k};
       $s->[1][$i] = $k;
       $s->[2][$i] = $v;
       $s->[0]{$k} = $i;
     }
     else {
       push(@k, $k);
       push(@v, $v);
       $len++;
     }
   }
   if (defined $len) {
     for (keys %{$s->[0]}) {
       $s->[0]{$_} += $len;
     }
     $i = 0;
     for (@k) {
       $s->[0]{$_} = $i++;
     }
     unshift(@{$s->[1]}, @k);
     return unshift(@{$s->[2]}, @v);
   }
   return scalar(@{$s->[1]});
 }
 
 sub Unshift2 {
   my($s) = shift;
   $s->Splice(0,0,@_);
   return scalar(@{$s->[1]});
 }
 
 sub Splice {
   my($s, $start, $len) = (shift, shift, shift);
   my($k, $v, @k, @v, @r, $i, $siz);
   my($end);                   
 
   ($start, $end, $len) = $s->_lrange($start, $len);
 
   if (defined $start) {
     if ($len > 0) {
       my(@k) = splice(@{$s->[1]}, $start, $len);
       my(@v) = splice(@{$s->[2]}, $start, $len);
       while (@k) {
         $k = shift(@k);
         delete $s->[0]{$k};
         push(@r, $k, shift(@v));
       }
       for ($start..$#{$s->[1]}) {
         $s->[0]{$s->[1][$_]} -= $len;
       }
     }
     while (@_) {
       ($k, $v) = (shift, shift);
       if (exists $s->[0]{$k}) {
         $i = $s->[0]{$k};
         $s->[1][$i] = $k;
         $s->[2][$i] = $v;
         $s->[0]{$k} = $i;
       }
       else {
         push(@k, $k);
         push(@v, $v);
         $siz++;
       }
     }
     if (defined $siz) {
       for ($start..$#{$s->[1]}) {
         $s->[0]{$s->[1][$_]} += $siz;
       }
       $i = $start;
       for (@k) {
         $s->[0]{$_} = $i++;
       }
       splice(@{$s->[1]}, $start, 0, @k);
       splice(@{$s->[2]}, $start, 0, @v);
     }
   }
   return @r;
 }
 
 sub Delete {
   my($s) = shift;
 
   for (@_) {
     $s->DELETE($_);
   }
 }
 
 sub Replace {
   my($s) = shift;
   my($i, $v, $k) = (shift, shift, shift);
   if (defined $i and $i <= $#{$s->[1]} and $i >= 0) {
     if (defined $k) {
       delete $s->[0]{ $s->[1][$i] };
       $s->DELETE($k) ; 
       $s->[1][$i] = $k;
       $s->[2][$i] = $v;
       $s->[0]{$k} = $i;
       return $k;
     }
     else {
       $s->[2][$i] = $v;
       return $s->[1][$i];
     }
   }
   return undef;
 }
 
 sub _lrange {
   my($s) = shift;
   my($offset, $len) = @_;
   my($start, $end);         
   my($size) = $#{$s->[1]}+1;
 
   return undef unless defined $offset;
   if($offset < 0) {
     $start = $offset + $size;
     $start = 0 if $start < 0;
   }
   else {
     ($offset > $size) ? ($start = $size) : ($start = $offset);
   }
 
   if (defined $len) {
     $len = -$len if $len < 0;
     $len = $size - $start if $len > $size - $start;
   }
   else {
     $len = $size - $start;
   }
   $end = $start + $len - 1;
 
   return ($start, $end, $len);
 }
 
 sub Keys   { 
   my($s) = shift;
   return ( @_ == 1
 	 ? $s->[1][$_[0]]
 	 : ( @_
 	   ? @{$s->[1]}[@_]
 	   : @{$s->[1]} ) );
 }
 
 sub Values {
   my($s) = shift;
   return ( @_ == 1
 	 ? $s->[2][$_[0]]
 	 : ( @_
 	   ? @{$s->[2]}[@_]
 	   : @{$s->[2]} ) );
 }
 
 sub Indices { 
   my($s) = shift;
   return ( @_ == 1 ? $s->[0]{$_[0]} : @{$s->[0]}{@_} );
 }
 
 sub Length {
  return scalar @{$_[0]->[1]};
 }
 
 sub Reorder {
   my($s) = shift;
   my(@k, @v, %x, $i);
   return unless @_;
 
   $i = 0;
   for (@_) {
     if (exists $s->[0]{$_}) {
       push(@k, $_);
       push(@v, $s->[2][ $s->[0]{$_} ] );
       $x{$_} = $i++;
     }
   }
   $s->[1] = \@k;
   $s->[2] = \@v;
   $s->[0] = \%x;
   return $s;
 }
 
 sub SortByKey {
   my($s) = shift;
   $s->Reorder(sort $s->Keys);
 }
 
 sub SortByValue {
   my($s) = shift;
   $s->Reorder(sort { $s->FETCH($a) cmp $s->FETCH($b) } $s->Keys)
 }
 
 1;
 __END__
 
### Time/Duration.pm ###
 package Time::Duration;
 $Time::Duration::VERSION = '1.20';
 use 5.006;
 use strict;
 use warnings;
 use constant DEBUG => 0;
 
 require Exporter;
 
 our @ISA         = ('Exporter');
 our @EXPORT      = qw( later later_exact earlier earlier_exact
                        ago ago_exact from_now from_now_exact
                        duration duration_exact
                        concise
                      );
 our @EXPORT_OK   = ('interval', @EXPORT);
 our $MILLISECOND = 0;
 
 
 
 sub concise ($) {
   my $string = $_[0];
   DEBUG and print "in : $string\n";
   $string =~ tr/,//d;
   $string =~ s/\band\b//;
   $string =~ s/\b(year|day|hour|minute|second)s?\b/substr($1,0,1)/eg;
   $string =~ s/\b(millisecond)s?\b/ms/g;
   $string =~ s/\s*(\d+)\s*/$1/g;
   return $string;
 }
 
 sub later {
   interval(      $_[0], $_[1], ' earlier', ' later', 'right then'); }
 sub later_exact {
   interval_exact($_[0], $_[1], ' earlier', ' later', 'right then'); }
 sub earlier {
   interval(      $_[0], $_[1], ' later', ' earlier', 'right then'); }
 sub earlier_exact {
   interval_exact($_[0], $_[1], ' later', ' earlier', 'right then'); }
 sub ago {
   interval(      $_[0], $_[1], ' from now', ' ago', 'right now'); }
 sub ago_exact {
   interval_exact($_[0], $_[1], ' from now', ' ago', 'right now'); }
 sub from_now {
   interval(      $_[0], $_[1], ' ago', ' from now', 'right now'); }
 sub from_now_exact {
   interval_exact($_[0], $_[1], ' ago', ' from now', 'right now'); }
 
 sub duration_exact {
   my $span = $_[0];   
   my $precision = int($_[1] || 0) || 2;  
   return '0 seconds' unless $span;
   _render('',
           _separate(abs $span));
 }
 
 sub duration {
   my $span = $_[0];   
   my $precision = int($_[1] || 0) || 2;  
   return '0 seconds' unless $span;
   _render('',
           _approximate($precision,
                        _separate(abs $span)));
 }
 
 
 sub interval_exact {
   my $span = $_[0];                    
   my $direction = ($span < 0) ? $_[2]  
                 : ($span > 0) ? $_[3]  
                 : return        $_[4]; 
   _render($direction,
           _separate($span));
 }
 
 sub interval {
   my $span = $_[0];                     
   my $precision = int($_[1] || 0) || 2; 
   my $direction = ($span < 0) ? $_[2]   
                 : ($span > 0) ? $_[3]   
                 : return        $_[4];  
   _render($direction,
           _approximate($precision,
                        _separate($span)));
 }
 
 
 use constant MINUTE => 60;
 use constant HOUR => 3600;
 use constant DAY  => 24 * HOUR;
 use constant YEAR => 365 * DAY;
 
 sub _separate {
   
   my $remainder = abs $_[0]; 
   my $this; 
   my @wheel; 
   
   $this = int($remainder / (365 * 24 * 60 * 60));
   push @wheel, ['year', $this, 1_000_000_000];
   $remainder -= $this * (365 * 24 * 60 * 60);
     
   $this = int($remainder / (24 * 60 * 60));
   push @wheel, ['day', $this, 365];
   $remainder -= $this * (24 * 60 * 60);
     
   $this = int($remainder / (60 * 60));
   push @wheel, ['hour', $this, 24];
   $remainder -= $this * (60 * 60);
   
   $this = int($remainder / 60);
   push @wheel, ['minute', $this, 60];
   $remainder -= $this * 60;
   
   push @wheel, ['second', int($remainder), 60];
 
 	if ($MILLISECOND) {
 		$remainder -= int($remainder);
 		push @wheel, ['millisecond', sprintf("%0.f", $remainder * 1000), 1000];
 	}
 
   return @wheel;
 }
 
 sub _approximate {
   my($precision, @wheel) = @_;
 
  Fix:
   {
   
     my $nonzero_count = 0;
     my $improperly_expressed;
 
     DEBUG and print join ' ', '#', (map "${$_}[1] ${$_}[0]",  @wheel), "\n";
     for(my $i = 0; $i < @wheel; $i++) {
       my $this = $wheel[$i];
       next if $this->[1] == 0; 
       ++$nonzero_count;
       next if $i == 0; 
       
       if($nonzero_count > $precision) {
         DEBUG and print '', $this->[0], " is one nonzero too many!\n";
 
         if($this->[1] >= ($this->[-1] / 2)) {
           DEBUG and printf "incrementing %s from %s to %s\n",
            $wheel[$i-1][0], $wheel[$i-1][1], 1 + $wheel[$i-1][1], ;
           ++$wheel[$i-1][1];
         }
 
         for(my $j = $i; $j < @wheel; $j++) { $wheel[$j][1] = 0 }
         redo Fix; 
       } elsif($this->[1] >= $this->[-1]) {
         $improperly_expressed = $i;
         DEBUG and print '', $this->[0], ' (', $this->[1], 
            ") is improper!\n";
       }
     }
     
     if(defined $improperly_expressed) {
       DEBUG and printf "incrementing %s from %s to %s\n",
        $wheel[$improperly_expressed-1][0], $wheel[$improperly_expressed-1][1], 
         1 + $wheel[$improperly_expressed-1][1], ;
       ++$wheel[ $improperly_expressed - 1][1];
       $wheel[ $improperly_expressed][1] = 0;
       redo Fix; 
     }
     
   }
 
   return @wheel;
 }
 
 sub _render {
 
   my $direction = shift @_;
   my @wheel = map
         {;
             (  $_->[1] == 0) ? ()  
             : ($_->[1] == 1) ? "${$_}[1] ${$_}[0]"  
             :                  "${$_}[1] ${$_}[0]s" 
         }
         @_
   ;
   return "just now" unless @wheel; 
   $wheel[-1] .= $direction;
   return $wheel[0] if @wheel == 1;
   return "$wheel[0] and $wheel[1]" if @wheel == 2;
   $wheel[-1] = "and $wheel[-1]";
   return join q{, }, @wheel;
 }
 
 1;
 
 __END__
 
 so "1y 0d 1h 50m 50s", N=3, so you round at minutes to "1y 0d 1h 51m 0s",
 #That's okay, so fall thru.
 
 so "1y 1d 0h 59m 50s", N=3, so you round at minutes to "1y 1d 0h 60m 0s",
 but that's not improperly expressed, so you loop around and get
 "1y 1d 1h 0m 0s", which is short enough, and is properly expressed.
 
 
 
### Try/Tiny.pm ###
 package Try::Tiny;
 BEGIN {
   $Try::Tiny::AUTHORITY = 'cpan:NUFFIN';
 }
 $Try::Tiny::VERSION = '0.22';
 use 5.006;
 
 use strict;
 use warnings;
 
 use Exporter 5.57 'import';
 our @EXPORT = our @EXPORT_OK = qw(try catch finally);
 
 use Carp;
 $Carp::Internal{+__PACKAGE__}++;
 
 BEGIN { eval "use Sub::Name; 1" or *{subname} = sub {1} }
 
 
 sub try (&;@) {
   my ( $try, @code_refs ) = @_;
 
   my $wantarray = wantarray;
 
   my ( $catch, @finally ) = ();
 
   foreach my $code_ref (@code_refs) {
 
     if ( ref($code_ref) eq 'Try::Tiny::Catch' ) {
       croak 'A try() may not be followed by multiple catch() blocks'
         if $catch;
       $catch = ${$code_ref};
     } elsif ( ref($code_ref) eq 'Try::Tiny::Finally' ) {
       push @finally, ${$code_ref};
     } else {
       croak(
         'try() encountered an unexpected argument ('
       . ( defined $code_ref ? $code_ref : 'undef' )
       . ') - perhaps a missing semi-colon before or'
       );
     }
   }
 
 
   my $caller = caller;
   subname("${caller}::try {...} " => $try);
   subname("${caller}::catch {...} " => $catch) if $catch;
   subname("${caller}::finally {...} " => $_) foreach @finally;
 
   my $prev_error = $@;
 
   my ( @ret, $error );
 
   my $failed = not eval {
     $@ = $prev_error;
 
     if ( $wantarray ) {
       @ret = $try->();
     } elsif ( defined $wantarray ) {
       $ret[0] = $try->();
     } else {
       $try->();
     };
 
     return 1; 
   };
 
   $error = $@;
   $@ = $prev_error;
 
   my @guards =
     map { Try::Tiny::ScopeGuard->_new($_, $failed ? $error : ()) }
     @finally;
 
   if ( $failed ) {
     if ( $catch ) {
       for ($error) {
         return $catch->($error);
       }
 
     }
 
     return;
   } else {
     return $wantarray ? @ret : $ret[0];
   }
 }
 
 sub catch (&;@) {
   my ( $block, @rest ) = @_;
 
   croak 'Useless bare catch()' unless wantarray;
 
   return (
     bless(\$block, 'Try::Tiny::Catch'),
     @rest,
   );
 }
 
 sub finally (&;@) {
   my ( $block, @rest ) = @_;
 
   croak 'Useless bare finally()' unless wantarray;
 
   return (
     bless(\$block, 'Try::Tiny::Finally'),
     @rest,
   );
 }
 
 {
   package 
     Try::Tiny::ScopeGuard;
 
   use constant UNSTABLE_DOLLARAT => ($] < '5.013002') ? 1 : 0;
 
   sub _new {
     shift;
     bless [ @_ ];
   }
 
   sub DESTROY {
     my ($code, @args) = @{ $_[0] };
 
     local $@ if UNSTABLE_DOLLARAT;
     eval {
       $code->(@args);
       1;
     } or do {
       warn
         "Execution of finally() block $code resulted in an exception, which "
       . '*CAN NOT BE PROPAGATED* due to fundamental limitations of Perl. '
       . 'Your program will continue as if this event never took place. '
       . "Original exception text follows:\n\n"
       . (defined $@ ? $@ : '$@ left undefined...')
       . "\n"
       ;
     }
   }
 }
 
 __PACKAGE__
 
 __END__
 
### URI.pm ###
 package URI;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 our ($ABS_REMOTE_LEADING_DOTS, $ABS_ALLOW_RELATIVE_SCHEME, $DEFAULT_QUERY_FORM_DELIMITER);
 
 my %implements;  
 
 
 our $reserved   = q(;/?:@&=+$,[]);
 our $mark       = q(-_.!~*'());                                    
 our $unreserved = "A-Za-z0-9\Q$mark\E";
 our $uric       = quotemeta($reserved) . $unreserved . "%";
 
 our $scheme_re  = '[a-zA-Z][a-zA-Z0-9.+\-]*';
 
 use Carp ();
 use URI::Escape ();
 
 use overload ('""'     => sub { ${$_[0]} },
               '=='     => sub { _obj_eq(@_) },
               '!='     => sub { !_obj_eq(@_) },
               fallback => 1,
              );
 
 sub _obj_eq {
     return overload::StrVal($_[0]) eq overload::StrVal($_[1]);
 }
 
 sub new
 {
     my($class, $uri, $scheme) = @_;
 
     $uri = defined ($uri) ? "$uri" : "";   
     $uri =~ s/^<(?:URL:)?(.*)>$/$1/;  
     $uri =~ s/^"(.*)"$/$1/;
     $uri =~ s/^\s+//;
     $uri =~ s/\s+$//;
 
     my $impclass;
     if ($uri =~ m/^($scheme_re):/so) {
 	$scheme = $1;
     }
     else {
 	if (($impclass = ref($scheme))) {
 	    $scheme = $scheme->scheme;
 	}
 	elsif ($scheme && $scheme =~ m/^($scheme_re)(?::|$)/o) {
 	    $scheme = $1;
         }
     }
     $impclass ||= implementor($scheme) ||
 	do {
 	    require URI::_foreign;
 	    $impclass = 'URI::_foreign';
 	};
 
     return $impclass->_init($uri, $scheme);
 }
 
 
 sub new_abs
 {
     my($class, $uri, $base) = @_;
     $uri = $class->new($uri, $base);
     $uri->abs($base);
 }
 
 
 sub _init
 {
     my $class = shift;
     my($str, $scheme) = @_;
     $str = $class->_uric_escape($str);
     $str = "$scheme:$str" unless $str =~ /^$scheme_re:/o ||
                                  $class->_no_scheme_ok;
     my $self = bless \$str, $class;
     $self;
 }
 
 
 sub _uric_escape
 {
     my($class, $str) = @_;
     $str =~ s*([^$uric\#])* URI::Escape::escape_char($1) *ego;
     utf8::downgrade($str);
     return $str;
 }
 
 
 sub implementor
 {
     my($scheme, $impclass) = @_;
     if (!$scheme || $scheme !~ /\A$scheme_re\z/o) {
 	require URI::_generic;
 	return "URI::_generic";
     }
 
     $scheme = lc($scheme);
 
     if ($impclass) {
         my $old = $implements{$scheme};
         $impclass->_init_implementor($scheme);
         $implements{$scheme} = $impclass;
         return $old;
     }
 
     my $ic = $implements{$scheme};
     return $ic if $ic;
 
     $ic = "URI::$scheme";  
 
     $ic =~ s/\+/_P/g;
     $ic =~ s/\./_O/g;
     $ic =~ s/\-/_/g;
 
     no strict 'refs';
     unless (@{"${ic}::ISA"}) {
         eval "require $ic";
         die $@ if $@ && $@ !~ /Can\'t locate.*in \@INC/;
         return undef unless @{"${ic}::ISA"};
     }
 
     $ic->_init_implementor($scheme);
     $implements{$scheme} = $ic;
     $ic;
 }
 
 
 sub _init_implementor
 {
     my($class, $scheme) = @_;
 }
 
 
 sub clone
 {
     my $self = shift;
     my $other = $$self;
     bless \$other, ref $self;
 }
 
 sub TO_JSON { ${$_[0]} }
 
 sub _no_scheme_ok { 0 }
 
 sub _scheme
 {
     my $self = shift;
 
     unless (@_) {
 	return undef unless $$self =~ /^($scheme_re):/o;
 	return $1;
     }
 
     my $old;
     my $new = shift;
     if (defined($new) && length($new)) {
 	Carp::croak("Bad scheme '$new'") unless $new =~ /^$scheme_re$/o;
 	$old = $1 if $$self =~ s/^($scheme_re)://o;
 	my $newself = URI->new("$new:$$self");
 	$$self = $$newself; 
 	bless $self, ref($newself);
     }
     else {
 	if ($self->_no_scheme_ok) {
 	    $old = $1 if $$self =~ s/^($scheme_re)://o;
 	    Carp::carp("Oops, opaque part now look like scheme")
 		if $^W && $$self =~ m/^$scheme_re:/o
 	}
 	else {
 	    $old = $1 if $$self =~ m/^($scheme_re):/o;
 	}
     }
 
     return $old;
 }
 
 sub scheme
 {
     my $scheme = shift->_scheme(@_);
     return undef unless defined $scheme;
     lc($scheme);
 }
 
 sub has_recognized_scheme {
     my $self = shift;
     return ref($self) !~ /^URI::_(?:foreign|generic)\z/;
 }
 
 sub opaque
 {
     my $self = shift;
 
     unless (@_) {
 	$$self =~ /^(?:$scheme_re:)?([^\#]*)/o or die;
 	return $1;
     }
 
     $$self =~ /^($scheme_re:)?    # optional scheme
 	        ([^\#]*)          # opaque
                 (\#.*)?           # optional fragment
               $/sx or die;
 
     my $old_scheme = $1;
     my $old_opaque = $2;
     my $old_frag   = $3;
 
     my $new_opaque = shift;
     $new_opaque = "" unless defined $new_opaque;
     $new_opaque =~ s/([^$uric])/ URI::Escape::escape_char($1)/ego;
     utf8::downgrade($new_opaque);
 
     $$self = defined($old_scheme) ? $old_scheme : "";
     $$self .= $new_opaque;
     $$self .= $old_frag if defined $old_frag;
 
     $old_opaque;
 }
 
 sub path { goto &opaque }  
 
 
 sub fragment
 {
     my $self = shift;
     unless (@_) {
 	return undef unless $$self =~ /\#(.*)/s;
 	return $1;
     }
 
     my $old;
     $old = $1 if $$self =~ s/\#(.*)//s;
 
     my $new_frag = shift;
     if (defined $new_frag) {
 	$new_frag =~ s/([^$uric])/ URI::Escape::escape_char($1) /ego;
 	utf8::downgrade($new_frag);
 	$$self .= "#$new_frag";
     }
     $old;
 }
 
 
 sub as_string
 {
     my $self = shift;
     $$self;
 }
 
 
 sub as_iri
 {
     my $self = shift;
     my $str = $$self;
     if ($str =~ s/%([89a-fA-F][0-9a-fA-F])/chr(hex($1))/eg) {
 
 	require Encode;
 	my $enc = Encode::find_encoding("UTF-8");
 	my $u = "";
 	while (length $str) {
 	    $u .= $enc->decode($str, Encode::FB_QUIET());
 	    if (length $str) {
 		$u .= URI::Escape::escape_char(substr($str, 0, 1, ""));
 	    }
 	}
 	$str = $u;
     }
     return $str;
 }
 
 
 sub canonical
 {
 
     my $self = shift;
     my $scheme = $self->_scheme || "";
     my $uc_scheme = $scheme =~ /[A-Z]/;
     my $esc = $$self =~ /%[a-fA-F0-9]{2}/;
     return $self unless $uc_scheme || $esc;
 
     my $other = $self->clone;
     if ($uc_scheme) {
 	$other->_scheme(lc $scheme);
     }
     if ($esc) {
 	$$other =~ s{%([0-9a-fA-F]{2})}
 	            { my $a = chr(hex($1));
                       $a =~ /^[$unreserved]\z/o ? $a : "%\U$1"
                     }ge;
     }
     return $other;
 }
 
 sub eq {
     my($self, $other) = @_;
     $self  = URI->new($self, $other) unless ref $self;
     $other = URI->new($other, $self) unless ref $other;
     ref($self) eq ref($other) &&                
 	$self->canonical->as_string eq $other->canonical->as_string;
 }
 
 sub abs { $_[0]; }
 sub rel { $_[0]; }
 
 sub secure { 0 }
 
 sub STORABLE_freeze {
        my($self, $cloning) = @_;
        return $$self;
 }
 
 sub STORABLE_thaw {
        my($self, $cloning, $str) = @_;
        $$self = $str;
 }
 
 1;
 
 __END__
 
### URI/Escape.pm ###
 package URI::Escape;
 
 use strict;
 use warnings;
 
 
 use Exporter 5.57 'import';
 our %escapes;
 our @EXPORT = qw(uri_escape uri_unescape uri_escape_utf8);
 our @EXPORT_OK = qw(%escapes);
 our $VERSION = "3.31";
 
 use Carp ();
 
 for (0..255) {
     $escapes{chr($_)} = sprintf("%%%02X", $_);
 }
 
 my %subst;  
 
 my %Unsafe = (
     RFC2732 => qr/[^A-Za-z0-9\-_.!~*'()]/,
     RFC3986 => qr/[^A-Za-z0-9\-\._~]/,
 );
 
 sub uri_escape {
     my($text, $patn) = @_;
     return undef unless defined $text;
     if (defined $patn){
         unless (exists  $subst{$patn}) {
             (my $tmp = $patn) =~ s,/,\\/,g;
             eval "\$subst{\$patn} = sub {\$_[0] =~ s/([$tmp])/\$escapes{\$1} || _fail_hi(\$1)/ge; }";
             Carp::croak("uri_escape: $@") if $@;
         }
         &{$subst{$patn}}($text);
     } else {
         $text =~ s/($Unsafe{RFC3986})/$escapes{$1} || _fail_hi($1)/ge;
     }
     $text;
 }
 
 sub _fail_hi {
     my $chr = shift;
     Carp::croak(sprintf "Can't escape \\x{%04X}, try uri_escape_utf8() instead", ord($chr));
 }
 
 sub uri_escape_utf8 {
     my $text = shift;
     utf8::encode($text);
     return uri_escape($text, @_);
 }
 
 sub uri_unescape {
     my $str = shift;
     if (@_ && wantarray) {
         my @str = ($str, @_);  
         for (@str) {
             s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
         }
         return @str;
     }
     $str =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg if defined $str;
     $str;
 }
 
 sub escape_char {
     my $dummy = substr($_[0], 0, 0);
 
     if (utf8::is_utf8($_[0])) {
         my $s = shift;
         utf8::encode($s);
         unshift(@_, $s);
     }
 
     return join '', @URI::Escape::escapes{split //, $_[0]};
 }
 
 1;
### URI/Find.pm ###
 
 package URI::Find;
 
 require 5.006;
 
 use strict;
 use base qw(Exporter);
 use vars qw($VERSION @EXPORT);
 
 $VERSION        = 20140709;
 @EXPORT         = qw(find_uris);
 
 use constant YES => (1==1);
 use constant NO  => !YES;
 
 use Carp        qw(croak);
 
 require URI;
 
 my $reserved   = q(;/?:@&=+$,[]);
 my $mark       = q(-_.!~*'());
 my $unreserved = "A-Za-z0-9\Q$mark\E";
 my $uric       = quotemeta($reserved) . '\p{isAlpha}' . $unreserved . "%";
 
 my($schemeRe) = qr/[a-zA-Z][a-zA-Z0-9\+]*/;
 my($uricSet)  = $uric; 
 
 my $extraSchemesRe = qr{^(?:git|svn|ssh|svn\+ssh)$};
 
 my($uricCheat) = __PACKAGE__->uric_set;
 $uricCheat =~ tr/://d;
 
 my($cruftSet) = q{])\},.'";}; 
 
 
 
 sub new {
     @_ == 2 || __PACKAGE__->badinvo;
     my($proto, $callback) = @_;
     my($class) = ref $proto || $proto;
     my $self = bless {}, $class;
 
     $self->{callback} = $callback;
 
     return $self;
 }
 
 
 sub find {
     @_ == 2 || @_ == 3 || __PACKAGE__->badinvo;
     my($self, $r_text, $escape_func) = @_;
 
     $escape_func ||= sub { return $_[0] };
 
     local $self->{escape_func} = $escape_func;
 
     $self->{_uris_found} = 0;
 
     local $SIG{__DIE__} = 'DEFAULT';
     my $uri_cand;
     my $uri;
 
     my $uriRe = sprintf '(?:%s|%s)', $self->uri_re, $self->schemeless_uri_re;
 
     $$r_text =~ s{ (.*?) (?:(<(?:URL:)?)(.+?)(>)|($uriRe)) | (.+?)$ }{
         my $replace = '';
         if( defined $6 ) {
             $replace = $escape_func->($6);
         }
         else {
             my $maybe_uri = '';
 
             $replace = $escape_func->($1) if length $1;
 
             if( defined $2 ) {
                 $maybe_uri = $3;
                 my $is_uri = do {  # Don't alter $1...
                     $maybe_uri =~ s/\s+//g;
                     $maybe_uri =~ /^$uriRe/;
                 };
 
                 if( $is_uri ) {
                     $replace .= $escape_func->($2);
                     $replace .= $self->_uri_filter($maybe_uri);
                     $replace .= $escape_func->($4);
                 }
                 else {
                     # the whole text inside of the <...> was not a url, but
                     # maybe it has a url (like an HTML <a> link)
                     my $has_uri = do { # Don't alter $1...
                         $maybe_uri = $3;
                         $maybe_uri =~ /$uriRe/;
                     };
                     if( $has_uri ) {
                         my $pre = $2;
                         my $post = $4;
                         do { $self->find(\$maybe_uri, $escape_func) };
                         $replace .= $escape_func->($pre);
                         $replace .= $maybe_uri;  # already escaped by find()
                         $replace .= $escape_func->($post);
                     }
                     else {
                         $replace .= $escape_func->($2.$3.$4);
                     }
                 }
             }
             else {
                 $replace .= $self->_uri_filter($5);
             }
         }
 
         $replace;
     }gsex;
 
     return $self->{_uris_found};
 }
 
 
 sub _uri_filter {
     my($self, $orig_match) = @_;
 
     $orig_match = $self->decruft($orig_match);
 
     my $replacement = '';
     if( my $uri = $self->_is_uri(\$orig_match) ) {
         $self->{_uris_found}++;
         $replacement = $self->{callback}->($uri, $orig_match);
     }
     else {
         $replacement = $self->{escape_func}->($orig_match);
     }
 
     return $self->recruft($replacement);
 }
 
 
 
 sub uri_re {
     @_ == 1 || __PACKAGE__->badinvo;
     my($self) = shift;
     return sprintf '%s:[%s][%s#]*', $schemeRe,
                                     $uricCheat,
                                     $self->uric_set;
 }
 
 
 sub schemeless_uri_re {
     @_ == 1 || __PACKAGE__->badinvo;
     my($self) = shift;
     return qr/\b\B/; 
 }
 
 
 sub uric_set {
     @_ == 1 || __PACKAGE__->badinvo;
     return $uricSet;
 }
 
 
 sub cruft_set {
     @_ == 1 || __PACKAGE__->badinvo;
     return $cruftSet;
 }
 
 
 my %balanced_cruft = (
     '('         => ')',
     '{'         => '}',
     '['         => ']',
     '"'         => '"',
     q[']        => q['],
 );
 
 sub decruft {
     @_ == 2 || __PACKAGE__->badinvo;
     my($self, $orig_match) = @_;
 
     $self->{start_cruft} = '';
     $self->{end_cruft} = '';
 
     if( $orig_match =~ s/([\Q$cruftSet\E]+)$// ) {
         my $cruft = $1;
         if( $cruft =~ /^;/ && $orig_match =~ /\&(\#[1-9]\d{1,3}|[a-zA-Z]{2,8})$/) {
             $orig_match .= ';';
             $cruft =~ s/^;//;
         }
 
         while( my($open, $close) = each %balanced_cruft ) {
             $self->recruft_balanced(\$orig_match, \$cruft, $open, $close);
         }
 
         $self->{end_cruft} = $cruft if $cruft;
     }
 
     return $orig_match;
 }
 
 
 sub recruft_balanced {
     my $self = shift;
     my($orig_match, $cruft, $open, $close) = @_;
 
     my $open_count  = () = $$orig_match =~ m{\Q$open}g;
     my $close_count = () = $$orig_match =~ m{\Q$close}g;
 
     if ( $$cruft =~ /\Q$close\E$/ && $open_count == ( $close_count + 1 ) ) {
         $$orig_match .= $close;
         $$cruft =~ s/\Q$close\E$//;
     }
 
     return;
 }
 
 
 
 
 sub recruft {
     @_ == 2 || __PACKAGE__->badinvo;
     my($self, $uri) = @_;
 
     return $self->{start_cruft} . $uri . $self->{end_cruft};
 }
 
 
 sub schemeless_to_schemed {
     @_ == 2 || __PACKAGE__->badinvo;
     my($self, $uri_cand) = @_;
 
     $uri_cand =~ s|^(<?)ftp\.|$1ftp://ftp\.|
         or $uri_cand =~ s|^(<?)|${1}http://|;
 
     return $uri_cand;
 }
 
 
 sub is_schemed {
     @_ == 2 || __PACKAGE__->badinvo;
     my($self, $uri) = @_;
     return scalar $uri =~ /^<?$schemeRe:/;
 }
 
 
 sub badinvo {
     my $package = shift;
     my $level   = @_ ? shift : 0;
     my $msg     = @_ ? " (" . shift() . ")" : '';
     my $subname = (caller $level + 1)[3];
     croak "Bogus invocation of $subname$msg";
 }
 
 
 sub find_uris (\$&) {
     @_ == 2 || __PACKAGE__->badinvo;
     my($r_text, $callback) = @_;
 
     my $self = __PACKAGE__->new($callback);
     return $self->find($r_text);
 }
 
 
 
 
 sub _is_uri {
     @_ == 2 || __PACKAGE__->badinvo;
     my($self, $r_uri_cand) = @_;
 
     my $uri = $$r_uri_cand;
 
     $uri = $self->schemeless_to_schemed($uri) if
       $uri =~ $self->schemeless_uri_re   and
       $uri !~ /^<?$schemeRe:/;
 
     eval {
         $uri = URI->new($uri);
 
         my $has_invalid_scheme = $uri->isa("URI::_foreign") &&
                                  $uri->scheme !~ $extraSchemesRe;
 
         my $is_empty = $uri =~ m{^$schemeRe://$};
 
         undef $uri if $has_invalid_scheme || $is_empty;
     };
 
     if($@ || !defined $uri) {   
         return NO;
     }
     else {                      
         return $uri;
     }
 }
 
 
 
 1;
### URI/Find/Schemeless.pm ###
 
 package URI::Find::Schemeless;
 
 use strict;
 use base qw(URI::Find);
 
 use URI::Find ();
 
 use vars qw($VERSION);
 $VERSION = 20140709;
 
 my($dnsSet) = '\p{isAlpha}A-Za-z0-9-'; 
 
 my($cruftSet) = __PACKAGE__->cruft_set . '<>?}';
 
 my($tldRe) = __PACKAGE__->top_level_domain_re;
 
 my($uricSet) = __PACKAGE__->uric_set;
 
 
 sub schemeless_uri_re {
     @_ == 1 || __PACKAGE__->badinvo;
     return qr{
               # Originally I constrained what couldn't be before the match
               # like this:  don't match email addresses, and don't start
               # anywhere but at the beginning of a host name
               #    (?<![\@.$dnsSet])
               # but I switched to saying what can be there after seeing a
               # false match of "Lite.pm" via "MIME/Lite.pm".
               (?: ^ | (?<=[\s<>()\{\}\[\]]) )
               # hostname
               (?: [$dnsSet]+(?:\.[$dnsSet]+)*\.$tldRe
                   | (?:\d{1,3}\.){3}\d{1,3} ) # not inet_aton() complete
               (?:
                   (?=[\s\Q$cruftSet\E]) # followed by unrelated thing
                   (?!\.\w)              #   but don't stop mid foo.xx.bar
                       (?<!\.p[ml])      #   but exclude Foo.pm and Foo.pl
                   |$                    # or end of line
                       (?<!\.p[ml])      #   but exclude Foo.pm and Foo.pl
                   |/[$uricSet#]*        # or slash and URI chars
               )
            }x;
 }
 
 
 sub top_level_domain_re {
     @_ == 1 || __PACKAGE__->badinvo;
     my($self) = shift;
 
     use utf8;
     my $plain = join '|', qw(
         AERO
         ARPA
         ASIA
         BIZ
         CAT
         COM
         COOP
         EDU
         GOV
         INFO
         INT
         JOBS
         MIL
         MOBI
         MUSEUM
         NAME
         NET
         ORG
         PRO
         TEL
         TRAVEL
         ac
         academy
         accountants
         active
         actor
         ad
         ae
         aero
         af
         ag
         agency
         ai
         airforce
         al
         am
         an
         ao
         aq
         ar
         archi
         army
         arpa
         as
         asia
         associates
         at
         attorney
         au
         audio
         autos
         aw
         ax
         axa
         az
         ba
         bar
         bargains
         bayern
         bb
         bd
         be
         beer
         berlin
         best
         bf
         bg
         bh
         bi
         bid
         bike
         bio
         biz
         bj
         bl
         black
         blackfriday
         blue
         bm
         bmw
         bn
         bo
         boutique
         bq
         br
         brussels
         bs
         bt
         build
         builders
         buzz
         bv
         bw
         by
         bz
         bzh
         ca
         cab
         camera
         camp
         capetown
         capital
         cards
         care
         career
         careers
         cash
         cat
         catering
         cc
         cd
         center
         ceo
         cf
         cg
         ch
         cheap
         christmas
         church
         ci
         citic
         ck
         cl
         claims
         cleaning
         clinic
         clothing
         club
         cm
         cn
         co
         codes
         coffee
         college
         cologne
         com
         community
         company
         computer
         condos
         construction
         consulting
         contractors
         cooking
         cool
         coop
         country
         cr
         credit
         creditcard
         cruises
         cu
         cv
         cw
         cx
         cy
         cz
         dance
         dating
         de
         degree
         democrat
         dental
         dentist
         desi
         diamonds
         digital
         directory
         discount
         dj
         dk
         dm
         dnp
         do
         domains
         durban
         dz
         ec
         edu
         education
         ee
         eg
         eh
         email
         engineer
         engineering
         enterprises
         equipment
         er
         es
         estate
         et
         eu
         eus
         events
         exchange
         expert
         exposed
         fail
         farm
         feedback
         fi
         finance
         financial
         fish
         fishing
         fitness
         fj
         fk
         flights
         florist
         fm
         fo
         foo
         foundation
         fr
         frogans
         fund
         furniture
         futbol
         ga
         gal
         gallery
         gb
         gd
         ge
         gf
         gg
         gh
         gi
         gift
         gives
         gl
         glass
         global
         globo
         gm
         gmo
         gn
         gop
         gov
         gp
         gq
         gr
         graphics
         gratis
         green
         gripe
         gs
         gt
         gu
         guide
         guitars
         guru
         gw
         gy
         hamburg
         haus
         hiphop
         hiv
         hk
         hm
         hn
         holdings
         holiday
         homes
         horse
         host
         house
         hr
         ht
         hu
         id
         ie
         il
         im
         immobilien
         in
         industries
         info
         ink
         institute
         insure
         int
         international
         investments
         io
         iq
         ir
         is
         it
         je
         jetzt
         jm
         jo
         jobs
         joburg
         jp
         juegos
         kaufen
         ke
         kg
         kh
         ki
         kim
         kitchen
         kiwi
         km
         kn
         koeln
         kp
         kr
         kred
         kw
         ky
         kz
         la
         land
         lawyer
         lb
         lc
         lease
         li
         life
         lighting
         limited
         limo
         link
         lk
         loans
         london
         lotto
         lr
         ls
         lt
         lu
         luxe
         luxury
         lv
         ly
         ma
         maison
         management
         mango
         market
         marketing
         mc
         md
         me
         media
         meet
         menu
         mf
         mg
         mh
         miami
         mil
         mini
         mk
         ml
         mm
         mn
         mo
         mobi
         moda
         moe
         monash
         mortgage
         moscow
         motorcycles
         mp
         mq
         mr
         ms
         mt
         mu
         museum
         mv
         mw
         mx
         my
         mz
         na
         nagoya
         name
         navy
         nc
         ne
         net
         neustar
         nf
         ng
         nhk
         ni
         ninja
         nl
         no
         np
         nr
         nu
         nyc
         nz
         okinawa
         om
         onl
         org
         organic
         ovh
         pa
         paris
         partners
         parts
         pe
         pf
         pg
         ph
         photo
         photography
         photos
         physio
         pics
         pictures
         pink
         pk
         pl
         plumbing
         pm
         pn
         post
         pr
         press
         pro
         productions
         properties
         ps
         pt
         pub
         pw
         py
         qa
         qpon
         quebec
         re
         recipes
         red
         rehab
         reise
         reisen
         ren
         rentals
         repair
         report
         republican
         rest
         reviews
         rich
         rio
         ro
         rocks
         rodeo
         rs
         ru
         ruhr
         rw
         ryukyu
         sa
         saarland
         sb
         sc
         schule
         scot
         sd
         se
         services
         sexy
         sg
         sh
         shiksha
         shoes
         si
         singles
         sj
         sk
         sl
         sm
         sn
         so
         social
         software
         sohu
         solar
         solutions
         soy
         space
         sr
         ss
         st
         su
         supplies
         supply
         support
         surf
         surgery
         sv
         sx
         sy
         systems
         sz
         tattoo
         tax
         tc
         td
         technology
         tel
         tf
         tg
         th
         tienda
         tips
         tirol
         tj
         tk
         tl
         tm
         tn
         to
         today
         tokyo
         tools
         town
         toys
         tp
         tr
         trade
         training
         travel
         tt
         tv
         tw
         tz
         ua
         ug
         uk
         um
         university
         uno
         us
         uy
         uz
         va
         vacations
         vc
         ve
         vegas
         ventures
         versicherung
         vet
         vg
         vi
         viajes
         villas
         vision
         vlaanderen
         vn
         vodka
         vote
         voting
         voto
         voyage
         vu
         wang
         watch
         webcam
         website
         wed
         wf
         wien
         wiki
         works
         ws
         wtc
         wtf
         测试
            परीक्षा
         集团
         在线
         한국
          ভারত
         موقع
          বাংলা
         公益
         公司
         移动
         我爱你
         москва
         испытание
         қаз
         онлайн
         сайт
         срб
         테스트
         орг
         삼성
           சிங்கப்பூர்
         商标
         商城
         дети
         мкд
         טעסט
         中文网
         中信
         中国
         中國
                      భారత్
                ලංකා
         測試
                 ભારત
            भारत
         آزمایشی
            பரிட்சை
            संगठन
         网络
         укр
         香港
         δοκιμή
         إختبار
         台湾
         台灣
         мон
         الجزائر
         عمان
         ایران
         امارات
         بازار
         پاکستان
         الاردن
         بھارت
         المغرب
         السعودية
         سودان
         مليسيا
         شبكة
         გე
         机构
         组织机构
                      ไทย
         سورية
         рф
         تونس
         みんな
         世界
                      ਭਾਰਤ
         网址
         游戏
         مصر
         قطر
           இலங்கை
           இந்தியா
         新加坡
         فلسطين
         テスト
         政务
         xxx
         xyz
         yachts
         ye
         yokohama
         yt
         za
         zm
         zone
         zw
     );
     
     return qr/(?:$plain)/i;
 }
 
 
 1;
### URI/Heuristic.pm ###
 package URI::Heuristic;
 
 
 use strict;
 use warnings;
 
 use Exporter 5.57 'import';
 our @EXPORT_OK = qw(uf_uri uf_uristr uf_url uf_urlstr);
 our $VERSION = "4.20";
 
 our ($MY_COUNTRY, $DEBUG);
 
 sub MY_COUNTRY() {
     for ($MY_COUNTRY) {
 	return $_ if defined;
 
 	$_ = $ENV{COUNTRY};
 	return $_ if defined;
 
 	my @srcs = ($ENV{LC_ALL}, $ENV{LANG});
 	if (my $httplang = $ENV{HTTP_ACCEPT_LANGUAGE}) {
 	    for $httplang (split(/\s*,\s*/, $httplang)) {
 		if ($httplang =~ /^\s*([a-zA-Z]+)[_-]([a-zA-Z]{2})\s*$/) {
 		    unshift(@srcs, "${1}_${2}");
 		    last;
 		}
 	    }
 	}
 	for (@srcs) {
 	    next unless defined;
 	    return lc($1) if /^[a-zA-Z]+_([a-zA-Z]{2})(?:[.@]|$)/;
 	}
 
 	require Net::Domain;
 	my $fqdn = Net::Domain::hostfqdn();
 	$_ = lc($1) if $fqdn =~ /\.([a-zA-Z]{2})$/;
 	return $_ if defined;
 
 	return ($_ = 0);
     }
 }
 
 our %LOCAL_GUESSING =
 (
  'us' => [qw(www.ACME.gov www.ACME.mil)],
  'gb' => [qw(www.ACME.co.uk www.ACME.org.uk www.ACME.ac.uk)],
  'au' => [qw(www.ACME.com.au www.ACME.org.au www.ACME.edu.au)],
  'il' => [qw(www.ACME.co.il www.ACME.org.il www.ACME.net.il)],
 );
 $LOCAL_GUESSING{uk} = $LOCAL_GUESSING{gb};
 
 
 sub uf_uristr ($)
 {
     local($_) = @_;
     print STDERR "uf_uristr: resolving $_\n" if $DEBUG;
     return unless defined;
 
     s/^\s+//;
     s/\s+$//;
 
     if (/^(www|web|home)[a-z0-9-]*(?:\.|$)/i) {
 	$_ = "http://$_";
 
     } elsif (/^(ftp|gopher|news|wais|https|http)[a-z0-9-]*(?:\.|$)/i) {
 	$_ = lc($1) . "://$_";
 
     } elsif ($^O ne "MacOS" && 
 	    (m,^/,      ||          
 	     m,^\.\.?/, ||          
 	     m,^[a-zA-Z]:[/\\],)    
 	    )
     {
 	$_ = "file:$_";
 
     } elsif ($^O eq "MacOS" && m/:/) {
 	unless (m/^(ftp|gopher|news|wais|http|https|mailto):/) {
 	    require URI::file;
 	    my $a = URI::file->new($_)->as_string;
 	    $_ = ($a =~ m/^file:/) ? $a : "file:$a";
 	}
     } elsif (/^\w+([\.\-]\w+)*\@(\w+\.)+\w{2,3}$/) {
 	$_ = "mailto:$_";
 
     } elsif (!/^[a-zA-Z][a-zA-Z0-9.+\-]*:/) {      
 	if (s/^([-\w]+(?:\.[-\w]+)*)([\/:\?\#]|$)/$2/) {
 	    my $host = $1;
 
 	    my $scheme = "http";
 	    if (/^:(\d+)\b/) {
 		if ($1 =~ /^[56789]?443$/) {
 		    $scheme = "https";
 		} elsif ($1 eq "21") {
 		    $scheme = "ftp";
 		}
 	    }
 
 	    if ($host !~ /\./ && $host ne "localhost") {
 		my @guess;
 		if (exists $ENV{URL_GUESS_PATTERN}) {
 		    @guess = map { s/\bACME\b/$host/; $_ }
 		             split(' ', $ENV{URL_GUESS_PATTERN});
 		} else {
 		    if (MY_COUNTRY()) {
 			my $special = $LOCAL_GUESSING{MY_COUNTRY()};
 			if ($special) {
 			    my @special = @$special;
 			    push(@guess, map { s/\bACME\b/$host/; $_ }
                                                @special);
 			} else {
 			    push(@guess, "www.$host." . MY_COUNTRY());
 			}
 		    }
 		    push(@guess, map "www.$host.$_",
 			             "com", "org", "net", "edu", "int");
 		}
 
 
 		my $guess;
 		for $guess (@guess) {
 		    print STDERR "uf_uristr: gethostbyname('$guess.')..."
 		      if $DEBUG;
 		    if (gethostbyname("$guess.")) {
 			print STDERR "yes\n" if $DEBUG;
 			$host = $guess;
 			last;
 		    }
 		    print STDERR "no\n" if $DEBUG;
 		}
 	    }
 	    $_ = "$scheme://$host$_";
 
 	} else {
 
 	}
     }
     print STDERR "uf_uristr: ==> $_\n" if $DEBUG;
 
     $_;
 }
 
 sub uf_uri ($)
 {
     require URI;
     URI->new(uf_uristr($_[0]));
 }
 
 *uf_urlstr = \*uf_uristr;
 
 sub uf_url ($)
 {
     require URI::URL;
     URI::URL->new(uf_uristr($_[0]));
 }
 
 1;
### URI/IRI.pm ###
 package URI::IRI;
 
 
 use strict;
 use warnings;
 use URI ();
 
 use overload '""' => sub { shift->as_string };
 
 our $VERSION = "1.69";
 
 sub new {
     my($class, $uri, $scheme) = @_;
     utf8::upgrade($uri);
     return bless {
 	uri => URI->new($uri, $scheme),
     }, $class;
 }
 
 sub clone {
     my $self = shift;
     return bless {
 	uri => $self->{uri}->clone,
     }, ref($self);
 }
 
 sub as_string {
     my $self = shift;
     return $self->{uri}->as_iri;
 }
 
 our $AUTOLOAD;
 sub AUTOLOAD
 {
     my $method = substr($AUTOLOAD, rindex($AUTOLOAD, '::')+2);
 
     no strict 'refs';
     *$method = sub { shift->{uri}->$method(@_) };
     goto &$method;
 }
 
 sub DESTROY {}   
 
 1;
### URI/QueryParam.pm ###
 package URI::QueryParam;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 sub URI::_query::query_param {
     my $self = shift;
     my @old = $self->query_form;
 
     if (@_ == 0) {
 	my (%seen, $i);
 	return grep !($i++ % 2 || $seen{$_}++), @old;
     }
 
     my $key = shift;
     my @i = grep $_ % 2 == 0 && $old[$_] eq $key, 0 .. $#old;
 
     if (@_) {
 	my @new = @old;
 	my @new_i = @i;
 	my @vals = map { ref($_) eq 'ARRAY' ? @$_ : $_ } @_;
 
 	while (@new_i > @vals) {
 	    splice @new, pop @new_i, 2;
 	}
 	if (@vals > @new_i) {
 	    my $i = @new_i ? $new_i[-1] + 2 : @new;
 	    my @splice = splice @vals, @new_i, @vals - @new_i;
 
 	    splice @new, $i, 0, map { $key => $_ } @splice;
 	}
 	if (@vals) {
 	    @new[ map $_ + 1, @new_i ] = @vals;
 	}
 
 	$self->query_form(\@new);
     }
 
     return wantarray ? @old[map $_+1, @i] : @i ? $old[$i[0]+1] : undef;
 }
 
 sub URI::_query::query_param_append {
     my $self = shift;
     my $key = shift;
     my @vals = map { ref $_ eq 'ARRAY' ? @$_ : $_ } @_;
     $self->query_form($self->query_form, $key => \@vals);  
     return;
 }
 
 sub URI::_query::query_param_delete {
     my $self = shift;
     my $key = shift;
     my @old = $self->query_form;
     my @vals;
 
     for (my $i = @old - 2; $i >= 0; $i -= 2) {
 	next if $old[$i] ne $key;
 	push(@vals, (splice(@old, $i, 2))[1]);
     }
     $self->query_form(\@old) if @vals;
     return wantarray ? reverse @vals : $vals[-1];
 }
 
 sub URI::_query::query_form_hash {
     my $self = shift;
     my @old = $self->query_form;
     if (@_) {
 	$self->query_form(@_ == 1 ? %{shift(@_)} : @_);
     }
     my %hash;
     while (my($k, $v) = splice(@old, 0, 2)) {
 	if (exists $hash{$k}) {
 	    for ($hash{$k}) {
 		$_ = [$_] unless ref($_) eq "ARRAY";
 		push(@$_, $v);
 	    }
 	}
 	else {
 	    $hash{$k} = $v;
 	}
     }
     return \%hash;
 }
 
 1;
 
 __END__
 
### URI/Split.pm ###
 package URI::Split;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use Exporter 5.57 'import';
 our @EXPORT_OK = qw(uri_split uri_join);
 
 use URI::Escape ();
 
 sub uri_split {
      return $_[0] =~ m,(?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?,;
 }
 
 sub uri_join {
     my($scheme, $auth, $path, $query, $frag) = @_;
     my $uri = defined($scheme) ? "$scheme:" : "";
     $path = "" unless defined $path;
     if (defined $auth) {
 	$auth =~ s,([/?\#]), URI::Escape::escape_char($1),eg;
 	$uri .= "//$auth";
 	$path = "/$path" if length($path) && $path !~ m,^/,;
     }
     elsif ($path =~ m,^//,) {
 	$uri .= "//";  
     }
     unless (length $uri) {
 	$path =~ s,(:), URI::Escape::escape_char($1),e while $path =~ m,^[^:/?\#]+:,;
     }
     $path =~ s,([?\#]), URI::Escape::escape_char($1),eg;
     $uri .= $path;
     if (defined $query) {
 	$query =~ s,(\#), URI::Escape::escape_char($1),eg;
 	$uri .= "?$query";
     }
     $uri .= "#$frag" if defined $frag;
     $uri;
 }
 
 1;
 
 __END__
 
### URI/URL.pm ###
 package URI::URL;
 
 use strict;
 use warnings;
 
 use parent 'URI::WithBase';
 
 our $VERSION = "5.04";
 
 
 use Exporter 5.57 'import';
 our @EXPORT = qw(url);
 
 sub url ($;$) { URI::URL->new(@_); }
 
 use URI::Escape qw(uri_unescape);
 
 sub new
 {
     my $class = shift;
     my $self = $class->SUPER::new(@_);
     $self->[0] = $self->[0]->canonical;
     $self;
 }
 
 sub newlocal
 {
     my $class = shift;
     require URI::file;
     bless [URI::file->new_abs(shift)], $class;
 }
 
 {package URI::_foreign;
     sub _init  
     {
 	my $class = shift;
 	die "Unknown URI::URL scheme $_[1]:" if $URI::URL::STRICT;
 	$class->SUPER::_init(@_);
     }
 }
 
 sub strict
 {
     my $old = $URI::URL::STRICT;
     $URI::URL::STRICT = shift if @_;
     $old;
 }
 
 sub print_on
 {
     my $self = shift;
     require Data::Dumper;
     print STDERR Data::Dumper::Dumper($self);
 }
 
 sub _try
 {
     my $self = shift;
     my $method = shift;
     scalar(eval { $self->$method(@_) });
 }
 
 sub crack
 {
     my $self = shift;
     (scalar($self->scheme),
      $self->_try("user"),
      $self->_try("password"),
      $self->_try("host"),
      $self->_try("port"),
      $self->_try("path"),
      $self->_try("params"),
      $self->_try("query"),
      scalar($self->fragment),
     )
 }
 
 sub full_path
 {
     my $self = shift;
     my $path = $self->path_query;
     $path = "/" unless length $path;
     $path;
 }
 
 sub netloc
 {
     shift->authority(@_);
 }
 
 sub epath
 {
     my $path = shift->SUPER::path(@_);
     $path =~ s/;.*//;
     $path;
 }
 
 sub eparams
 {
     my $self = shift;
     my @p = $self->path_segments;
     return undef unless ref($p[-1]);
     @p = @{$p[-1]};
     shift @p;
     join(";", @p);
 }
 
 sub params { shift->eparams(@_); }
 
 sub path {
     my $self = shift;
     my $old = $self->epath(@_);
     return unless defined wantarray;
     return '/' if !defined($old) || !length($old);
     Carp::croak("Path components contain '/' (you must call epath)")
 	if $old =~ /%2[fF]/ and !@_;
     $old = "/$old" if $old !~ m|^/| && defined $self->netloc;
     return uri_unescape($old);
 }
 
 sub path_components {
     shift->path_segments(@_);
 }
 
 sub query {
     my $self = shift;
     my $old = $self->equery(@_);
     if (defined(wantarray) && defined($old)) {
 	if ($old =~ /%(?:26|2[bB]|3[dD])/) {  
 	    my $mess;
 	    for ($old) {
 		$mess = "Query contains both '+' and '%2B'"
 		  if /\+/ && /%2[bB]/;
 		$mess = "Form query contains escaped '=' or '&'"
 		  if /=/  && /%(?:3[dD]|26)/;
 	    }
 	    if ($mess) {
 		Carp::croak("$mess (you must call equery)");
 	    }
 	}
 	return uri_unescape($old);
     }
     undef;
 
 }
 
 sub abs
 {
     my $self = shift;
     my $base = shift;
     my $allow_scheme = shift;
     $allow_scheme = $URI::URL::ABS_ALLOW_RELATIVE_SCHEME
 	unless defined $allow_scheme;
     local $URI::ABS_ALLOW_RELATIVE_SCHEME = $allow_scheme;
     local $URI::ABS_REMOTE_LEADING_DOTS = $URI::URL::ABS_REMOTE_LEADING_DOTS;
     $self->SUPER::abs($base);
 }
 
 sub frag { shift->fragment(@_); }
 sub keywords { shift->query_keywords(@_); }
 
 sub local_path { shift->file; }
 sub unix_path  { shift->file("unix"); }
 sub dos_path   { shift->file("dos");  }
 sub mac_path   { shift->file("mac");  }
 sub vms_path   { shift->file("vms");  }
 
 sub address { shift->to(@_); }
 sub encoded822addr { shift->to(@_); }
 sub URI::mailto::authority { shift->to(@_); }  
 
 sub groupart { shift->_group(@_); }
 sub article  { shift->message(@_); }
 
 1;
 
 __END__
 
### URI/WithBase.pm ###
 package URI::WithBase;
 
 use strict;
 use warnings;
 
 use URI;
 use Scalar::Util 'blessed';
 
 our $VERSION = "2.20";
 
 use overload '""' => "as_string", fallback => 1;
 
 sub as_string;  
 
 sub new
 {
     my($class, $uri, $base) = @_;
     my $ibase = $base;
     if ($base && blessed($base) && $base->isa(__PACKAGE__)) {
 	$base = $base->abs;
 	$ibase = $base->[0];
     }
     bless [URI->new($uri, $ibase), $base], $class;
 }
 
 sub new_abs
 {
     my $class = shift;
     my $self = $class->new(@_);
     $self->abs;
 }
 
 sub _init
 {
     my $class = shift;
     my($str, $scheme) = @_;
     bless [URI->new($str, $scheme), undef], $class;
 }
 
 sub eq
 {
     my($self, $other) = @_;
     $other = $other->[0] if blessed($other) and $other->isa(__PACKAGE__);
     $self->[0]->eq($other);
 }
 
 our $AUTOLOAD;
 sub AUTOLOAD
 {
     my $self = shift;
     my $method = substr($AUTOLOAD, rindex($AUTOLOAD, '::')+2);
     return if $method eq "DESTROY";
     $self->[0]->$method(@_);
 }
 
 sub can {                                  
     my $self = shift;
     $self->SUPER::can(@_) || (
       ref($self)
       ? $self->[0]->can(@_)
       : undef
     )
 }
 
 sub base {
     my $self = shift;
     my $base  = $self->[1];
 
     if (@_) { 
 	my $new_base = shift;
 	$new_base = $new_base->abs if ref($new_base) && $new_base->isa(__PACKAGE__);
 	$self->[1] = $new_base;
     }
     return unless defined wantarray;
 
     if (defined($base) && !ref($base)) {
 	$base = ref($self)->new($base);
 	$self->[1] = $base unless @_;
     }
     $base;
 }
 
 sub clone
 {
     my $self = shift;
     my $base = $self->[1];
     $base = $base->clone if ref($base);
     bless [$self->[0]->clone, $base], ref($self);
 }
 
 sub abs
 {
     my $self = shift;
     my $base = shift || $self->base || return $self->clone;
     $base = $base->as_string if ref($base);
     bless [$self->[0]->abs($base, @_), $base], ref($self);
 }
 
 sub rel
 {
     my $self = shift;
     my $base = shift || $self->base || return $self->clone;
     $base = $base->as_string if ref($base);
     bless [$self->[0]->rel($base, @_), $base], ref($self);
 }
 
 1;
 
 __END__
 
### URI/_foreign.pm ###
 package URI::_foreign;
 
 use strict;
 use warnings;
 
 use parent 'URI::_generic';
 
 our $VERSION = "1.69";
 
 1;
### URI/_generic.pm ###
 package URI::_generic;
 
 use strict;
 use warnings;
 
 use parent qw(URI URI::_query);
 
 use URI::Escape qw(uri_unescape);
 use Carp ();
 
 our $VERSION = "1.69";
 
 my $ACHAR = $URI::uric;  $ACHAR =~ s,\\[/?],,g;
 my $PCHAR = $URI::uric;  $PCHAR =~ s,\\[?],,g;
 
 sub _no_scheme_ok { 1 }
 
 sub authority
 {
     my $self = shift;
     $$self =~ m,^((?:$URI::scheme_re:)?)(?://([^/?\#]*))?(.*)$,os or die;
 
     if (@_) {
 	my $auth = shift;
 	$$self = $1;
 	my $rest = $3;
 	if (defined $auth) {
 	    $auth =~ s/([^$ACHAR])/ URI::Escape::escape_char($1)/ego;
 	    utf8::downgrade($auth);
 	    $$self .= "//$auth";
 	}
 	_check_path($rest, $$self);
 	$$self .= $rest;
     }
     $2;
 }
 
 sub path
 {
     my $self = shift;
     $$self =~ m,^((?:[^:/?\#]+:)?(?://[^/?\#]*)?)([^?\#]*)(.*)$,s or die;
 
     if (@_) {
 	$$self = $1;
 	my $rest = $3;
 	my $new_path = shift;
 	$new_path = "" unless defined $new_path;
 	$new_path =~ s/([^$PCHAR])/ URI::Escape::escape_char($1)/ego;
 	utf8::downgrade($new_path);
 	_check_path($new_path, $$self);
 	$$self .= $new_path . $rest;
     }
     $2;
 }
 
 sub path_query
 {
     my $self = shift;
     $$self =~ m,^((?:[^:/?\#]+:)?(?://[^/?\#]*)?)([^\#]*)(.*)$,s or die;
 
     if (@_) {
 	$$self = $1;
 	my $rest = $3;
 	my $new_path = shift;
 	$new_path = "" unless defined $new_path;
 	$new_path =~ s/([^$URI::uric])/ URI::Escape::escape_char($1)/ego;
 	utf8::downgrade($new_path);
 	_check_path($new_path, $$self);
 	$$self .= $new_path . $rest;
     }
     $2;
 }
 
 sub _check_path
 {
     my($path, $pre) = @_;
     my $prefix;
     if ($pre =~ m,/,) {  
 	$prefix = "/" if length($path) && $path !~ m,^[/?\#],;
     }
     else {
 	if ($path =~ m,^//,) {
 	    Carp::carp("Path starting with double slash is confusing")
 		if $^W;
 	}
 	elsif (!length($pre) && $path =~ m,^[^:/?\#]+:,) {
 	    Carp::carp("Path might look like scheme, './' prepended")
 		if $^W;
 	    $prefix = "./";
 	}
     }
     substr($_[0], 0, 0) = $prefix if defined $prefix;
 }
 
 sub path_segments
 {
     my $self = shift;
     my $path = $self->path;
     if (@_) {
 	my @arg = @_;  
 	for (@arg) {
 	    if (ref($_)) {
 		my @seg = @$_;
 		$seg[0] =~ s/%/%25/g;
 		for (@seg) { s/;/%3B/g; }
 		$_ = join(";", @seg);
 	    }
 	    else {
 		 s/%/%25/g; s/;/%3B/g;
 	    }
 	    s,/,%2F,g;
 	}
 	$self->path(join("/", @arg));
     }
     return $path unless wantarray;
     map {/;/ ? $self->_split_segment($_)
              : uri_unescape($_) }
         split('/', $path, -1);
 }
 
 
 sub _split_segment
 {
     my $self = shift;
     require URI::_segment;
     URI::_segment->new(@_);
 }
 
 
 sub abs
 {
     my $self = shift;
     my $base = shift || Carp::croak("Missing base argument");
 
     if (my $scheme = $self->scheme) {
 	return $self unless $URI::ABS_ALLOW_RELATIVE_SCHEME;
 	$base = URI->new($base) unless ref $base;
 	return $self unless $scheme eq $base->scheme;
     }
 
     $base = URI->new($base) unless ref $base;
     my $abs = $self->clone;
     $abs->scheme($base->scheme);
     return $abs if $$self =~ m,^(?:$URI::scheme_re:)?//,o;
     $abs->authority($base->authority);
 
     my $path = $self->path;
     return $abs if $path =~ m,^/,;
 
     if (!length($path)) {
 	my $abs = $base->clone;
 	my $query = $self->query;
 	$abs->query($query) if defined $query;
 	my $fragment = $self->fragment;
 	$abs->fragment($fragment) if defined $fragment;
 	return $abs;
     }
 
     my $p = $base->path;
     $p =~ s,[^/]+$,,;
     $p .= $path;
     my @p = split('/', $p, -1);
     shift(@p) if @p && !length($p[0]);
     my $i = 1;
     while ($i < @p) {
 	if ($p[$i-1] eq ".") {
 	    splice(@p, $i-1, 1);
 	    $i-- if $i > 1;
 	}
 	elsif ($p[$i] eq ".." && $p[$i-1] ne "..") {
 	    splice(@p, $i-1, 2);
 	    if ($i > 1) {
 		$i--;
 		push(@p, "") if $i == @p;
 	    }
 	}
 	else {
 	    $i++;
 	}
     }
     $p[-1] = "" if @p && $p[-1] eq ".";  
     if ($URI::ABS_REMOTE_LEADING_DOTS) {
         shift @p while @p && $p[0] =~ /^\.\.?$/;
     }
     $abs->path("/" . join("/", @p));
     $abs;
 }
 
 sub rel {
     my $self = shift;
     my $base = shift || Carp::croak("Missing base argument");
     my $rel = $self->clone;
     $base = URI->new($base) unless ref $base;
 
     my $scheme = $rel->scheme;
     my $auth   = $rel->canonical->authority;
     my $path   = $rel->path;
 
     if (!defined($scheme) && !defined($auth)) {
 	return $rel;
     }
 
     my $bscheme = $base->scheme;
     my $bauth   = $base->canonical->authority;
     my $bpath   = $base->path;
 
     for ($bscheme, $bauth, $auth) {
 	$_ = '' unless defined
     }
 
     unless ($scheme eq $bscheme && $auth eq $bauth) {
 	return $rel;
     }
 
     for ($path, $bpath) {  $_ = "/$_" unless m,^/,; }
 
     $rel->scheme(undef);
     $rel->authority(undef);
 
     my $li = 1;
     while (1) {
 	my $i = index($path, '/', $li);
 	last if $i < 0 ||
                 $i != index($bpath, '/', $li) ||
 	        substr($path,$li,$i-$li) ne substr($bpath,$li,$i-$li);
 	$li=$i+1;
     }
     substr($path, 0,$li) = '';
     substr($bpath,0,$li) = '';
 
     if ($path eq $bpath &&
         defined($rel->fragment) &&
         !defined($rel->query)) {
         $rel->path("");
     }
     else {
         $path = ('../' x $bpath =~ tr|/|/|) . $path;
 	$path = "./" if $path eq "";
         $rel->path($path);
     }
 
     $rel;
 }
 
 1;
### URI/_idna.pm ###
 package URI::_idna;
 
 
 use strict;
 use warnings;
 
 use URI::_punycode qw(encode_punycode decode_punycode);
 use Carp qw(croak);
 
 our $VERSION = "1.69";
 
 BEGIN {
   *URI::_idna::_ENV_::JOIN_LEAKS_UTF8_FLAGS = $] < 5.008_003
     ? sub () { 1 }
     : sub () { 0 }
   ;
 }
 
 my $ASCII = qr/^[\x00-\x7F]*\z/;
 
 sub encode {
     my $idomain = shift;
     my @labels = split(/\./, $idomain, -1);
     my @last_empty;
     push(@last_empty, pop @labels) if @labels > 1 && $labels[-1] eq "";
     for (@labels) {
 	$_ = ToASCII($_);
     }
 
     return eval 'join(".", @labels, @last_empty)' if URI::_idna::_ENV_::JOIN_LEAKS_UTF8_FLAGS;
     return join(".", @labels, @last_empty);
 }
 
 sub decode {
     my $domain = shift;
     return join(".", map ToUnicode($_), split(/\./, $domain, -1))
 }
 
 sub nameprep { 
     my $label = shift;
     $label = lc($label);
     return $label;
 }
 
 sub check_size {
     my $label = shift;
     croak "Label empty" if $label eq "";
     croak "Label too long" if length($label) > 63;
     return $label;
 }
 
 sub ToASCII {
     my $label = shift;
     return check_size($label) if $label =~ $ASCII;
 
     $label = nameprep($label);
     return check_size($label) if $label =~ $ASCII;
 
     if ($label =~ /^xn--/) {
         croak "Label starts with ACE prefix";
     }
 
     $label = encode_punycode($label);
 
     $label = "xn--$label";
 
     return check_size($label);
 }
 
 sub ToUnicode {
     my $label = shift;
     $label = nameprep($label) unless $label =~ $ASCII;
     return $label unless $label =~ /^xn--/;
     my $result = decode_punycode(substr($label, 4));
     my $label2 = ToASCII($result);
     if (lc($label) ne $label2) {
 	croak "IDNA does not round-trip: '\L$label\E' vs '$label2'";
     }
     return $result;
 }
 
 1;
### URI/_ldap.pm ###
 
 package URI::_ldap;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use URI::Escape qw(uri_unescape);
 
 sub _ldap_elem {
   my $self  = shift;
   my $elem  = shift;
   my $query = $self->query;
   my @bits  = (split(/\?/,defined($query) ? $query : ""),("")x4);
   my $old   = $bits[$elem];
 
   if (@_) {
     my $new = shift;
     $new =~ s/\?/%3F/g;
     $bits[$elem] = $new;
     $query = join("?",@bits);
     $query =~ s/\?+$//;
     $query = undef unless length($query);
     $self->query($query);
   }
 
   $old;
 }
 
 sub dn {
   my $old = shift->path(@_);
   $old =~ s:^/::;
   uri_unescape($old);
 }
 
 sub attributes {
   my $self = shift;
   my $old = _ldap_elem($self,0, @_ ? join(",", map { my $tmp = $_; $tmp =~ s/,/%2C/g; $tmp } @_) : ());
   return $old unless wantarray;
   map { uri_unescape($_) } split(/,/,$old);
 }
 
 sub _scope {
   my $self = shift;
   my $old = _ldap_elem($self,1, @_);
   return undef unless defined wantarray && defined $old;
   uri_unescape($old);
 }
 
 sub scope {
   my $old = &_scope;
   $old = "base" unless length $old;
   $old;
 }
 
 sub _filter {
   my $self = shift;
   my $old = _ldap_elem($self,2, @_);
   return undef unless defined wantarray && defined $old;
   uri_unescape($old); 
 }
 
 sub filter {
   my $old = &_filter;
   $old = "(objectClass=*)" unless length $old;
   $old;
 }
 
 sub extensions {
   my $self = shift;
   my @ext;
   while (@_) {
     my $key = shift;
     my $value = shift;
     push(@ext, join("=", map { $_="" unless defined; s/,/%2C/g; $_ } $key, $value));
   }
   @ext = join(",", @ext) if @ext;
   my $old = _ldap_elem($self,3, @ext);
   return $old unless wantarray;
   map { uri_unescape($_) } map { /^([^=]+)=(.*)$/ } split(/,/,$old);
 }
 
 sub canonical
 {
     my $self = shift;
     my $other = $self->_nonldap_canonical;
 
 
     $other = $other->clone if $other == $self;
 
     $other->dn(_normalize_dn($other->dn));
 
     $other->attributes(map lc, $other->attributes);
 
     my $old_scope = $other->scope;
     my $new_scope = lc($old_scope);
     $new_scope = "" if $new_scope eq "base";
     $other->scope($new_scope) if $new_scope ne $old_scope;
 
     my $old_filter = $other->filter;
     $other->filter("") if lc($old_filter) eq "(objectclass=*)" ||
 	                  lc($old_filter) eq "objectclass=*";
 
     my @ext = $other->extensions;
     for (my $i = 0; $i < @ext; $i += 2) {
 	my $etype = $ext[$i] = lc($ext[$i]);
 	if ($etype =~ /^!?bindname$/) {
 	    $ext[$i+1] = _normalize_dn($ext[$i+1]);
 	}
     }
     $other->extensions(@ext) if @ext;
     
     $other;
 }
 
 sub _normalize_dn  
 {
     my $dn = shift;
 
     return $dn;
 
     my @dn = split(/([+,])/, $dn);
     for (@dn) {
 	s/^([a-zA-Z]+=)/lc($1)/e;
     }
     join("", @dn);
 }
 
 1;
### URI/_login.pm ###
 package URI::_login;
 
 use strict;
 use warnings;
 
 use parent qw(URI::_server URI::_userpass);
 
 our $VERSION = "1.69";
 
 
 1;
### URI/_punycode.pm ###
 package URI::_punycode;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use Exporter 'import';
 our @EXPORT = qw(encode_punycode decode_punycode);
 
 use integer;
 
 our $DEBUG = 0;
 
 use constant BASE => 36;
 use constant TMIN => 1;
 use constant TMAX => 26;
 use constant SKEW => 38;
 use constant DAMP => 700;
 use constant INITIAL_BIAS => 72;
 use constant INITIAL_N => 128;
 
 my $Delimiter = chr 0x2D;
 my $BasicRE   = qr/[\x00-\x7f]/;
 
 sub _croak { require Carp; Carp::croak(@_); }
 
 sub digit_value {
     my $code = shift;
     return ord($code) - ord("A") if $code =~ /[A-Z]/;
     return ord($code) - ord("a") if $code =~ /[a-z]/;
     return ord($code) - ord("0") + 26 if $code =~ /[0-9]/;
     return;
 }
 
 sub code_point {
     my $digit = shift;
     return $digit + ord('a') if 0 <= $digit && $digit <= 25;
     return $digit + ord('0') - 26 if 26 <= $digit && $digit <= 36;
     die 'NOT COME HERE';
 }
 
 sub adapt {
     my($delta, $numpoints, $firsttime) = @_;
     $delta = $firsttime ? $delta / DAMP : $delta / 2;
     $delta += $delta / $numpoints;
     my $k = 0;
     while ($delta > ((BASE - TMIN) * TMAX) / 2) {
 	$delta /= BASE - TMIN;
 	$k += BASE;
     }
     return $k + (((BASE - TMIN + 1) * $delta) / ($delta + SKEW));
 }
 
 sub decode_punycode {
     my $code = shift;
 
     my $n      = INITIAL_N;
     my $i      = 0;
     my $bias   = INITIAL_BIAS;
     my @output;
 
     if ($code =~ s/(.*)$Delimiter//o) {
 	push @output, map ord, split //, $1;
 	return _croak('non-basic code point') unless $1 =~ /^$BasicRE*$/o;
     }
 
     while ($code) {
 	my $oldi = $i;
 	my $w    = 1;
     LOOP:
 	for (my $k = BASE; 1; $k += BASE) {
 	    my $cp = substr($code, 0, 1, '');
 	    my $digit = digit_value($cp);
 	    defined $digit or return _croak("invalid punycode input");
 	    $i += $digit * $w;
 	    my $t = ($k <= $bias) ? TMIN
 		: ($k >= $bias + TMAX) ? TMAX : $k - $bias;
 	    last LOOP if $digit < $t;
 	    $w *= (BASE - $t);
 	}
 	$bias = adapt($i - $oldi, @output + 1, $oldi == 0);
 	warn "bias becomes $bias" if $DEBUG;
 	$n += $i / (@output + 1);
 	$i = $i % (@output + 1);
 	splice(@output, $i, 0, $n);
 	warn join " ", map sprintf('%04x', $_), @output if $DEBUG;
 	$i++;
     }
     return join '', map chr, @output;
 }
 
 sub encode_punycode {
     my $input = shift;
     my @input = split //, $input;
 
     my $n     = INITIAL_N;
     my $delta = 0;
     my $bias  = INITIAL_BIAS;
 
     my @output;
     my @basic = grep /$BasicRE/, @input;
     my $h = my $b = @basic;
     push @output, @basic;
     push @output, $Delimiter if $b && $h < @input;
     warn "basic codepoints: (@output)" if $DEBUG;
 
     while ($h < @input) {
 	my $m = min(grep { $_ >= $n } map ord, @input);
 	warn sprintf "next code point to insert is %04x", $m if $DEBUG;
 	$delta += ($m - $n) * ($h + 1);
 	$n = $m;
 	for my $i (@input) {
 	    my $c = ord($i);
 	    $delta++ if $c < $n;
 	    if ($c == $n) {
 		my $q = $delta;
 	    LOOP:
 		for (my $k = BASE; 1; $k += BASE) {
 		    my $t = ($k <= $bias) ? TMIN :
 			($k >= $bias + TMAX) ? TMAX : $k - $bias;
 		    last LOOP if $q < $t;
 		    my $cp = code_point($t + (($q - $t) % (BASE - $t)));
 		    push @output, chr($cp);
 		    $q = ($q - $t) / (BASE - $t);
 		}
 		push @output, chr(code_point($q));
 		$bias = adapt($delta, $h + 1, $h == $b);
 		warn "bias becomes $bias" if $DEBUG;
 		$delta = 0;
 		$h++;
 	    }
 	}
 	$delta++;
 	$n++;
     }
     return join '', @output;
 }
 
 sub min {
     my $min = shift;
     for (@_) { $min = $_ if $_ <= $min }
     return $min;
 }
 
 1;
 __END__
 
### URI/_query.pm ###
 package URI::_query;
 
 use strict;
 use warnings;
 
 use URI ();
 use URI::Escape qw(uri_unescape);
 
 our $VERSION = "1.69";
 
 sub query
 {
     my $self = shift;
     $$self =~ m,^([^?\#]*)(?:\?([^\#]*))?(.*)$,s or die;
 
     if (@_) {
 	my $q = shift;
 	$$self = $1;
 	if (defined $q) {
 	    $q =~ s/([^$URI::uric])/ URI::Escape::escape_char($1)/ego;
 	    utf8::downgrade($q);
 	    $$self .= "?$q";
 	}
 	$$self .= $3;
     }
     $2;
 }
 
 sub query_form {
     my $self = shift;
     my $old = $self->query;
     if (@_) {
         my $delim;
         my $r = $_[0];
         if (ref($r) eq "ARRAY") {
             $delim = $_[1];
             @_ = @$r;
         }
         elsif (ref($r) eq "HASH") {
             $delim = $_[1];
             @_ = map { $_ => $r->{$_} } sort keys %$r;
         }
         $delim = pop if @_ % 2;
 
         my @query;
         while (my($key,$vals) = splice(@_, 0, 2)) {
             $key = '' unless defined $key;
 	    $key =~ s/([;\/?:@&=+,\$\[\]%])/ URI::Escape::escape_char($1)/eg;
 	    $key =~ s/ /+/g;
 	    $vals = [ref($vals) eq "ARRAY" ? @$vals : $vals];
             for my $val (@$vals) {
                 $val = '' unless defined $val;
 		$val =~ s/([;\/?:@&=+,\$\[\]%])/ URI::Escape::escape_char($1)/eg;
                 $val =~ s/ /+/g;
                 push(@query, "$key=$val");
             }
         }
         if (@query) {
             unless ($delim) {
                 $delim = $1 if $old && $old =~ /([&;])/;
                 $delim ||= $URI::DEFAULT_QUERY_FORM_DELIMITER || "&";
             }
             $self->query(join($delim, @query));
         }
         else {
             $self->query(undef);
         }
     }
     return if !defined($old) || !length($old) || !defined(wantarray);
     return unless $old =~ /=/; 
     map { s/\+/ /g; uri_unescape($_) }
          map { /=/ ? split(/=/, $_, 2) : ($_ => '')} split(/[&;]/, $old);
 }
 
 sub query_keywords
 {
     my $self = shift;
     my $old = $self->query;
     if (@_) {
 	my @copy = @_;
 	@copy = @{$copy[0]} if @copy == 1 && ref($copy[0]) eq "ARRAY";
 	for (@copy) { s/([;\/?:@&=+,\$\[\]%])/ URI::Escape::escape_char($1)/eg; }
 	$self->query(@copy ? join('+', @copy) : undef);
     }
     return if !defined($old) || !defined(wantarray);
     return if $old =~ /=/;  
     map { uri_unescape($_) } split(/\+/, $old, -1);
 }
 
 sub equery { goto &query }
 
 1;
### URI/_segment.pm ###
 package URI::_segment;
 
 
 use strict;
 use warnings;
 
 use URI::Escape qw(uri_unescape);
 
 use overload '""' => sub { $_[0]->[0] },
              fallback => 1;
 
 our $VERSION = "1.69";
 
 sub new
 {
     my $class = shift;
     my @segment = split(';', shift, -1);
     $segment[0] = uri_unescape($segment[0]);
     bless \@segment, $class;
 }
 
 1;
### URI/_server.pm ###
 package URI::_server;
 
 use strict;
 use warnings;
 
 use parent 'URI::_generic';
 
 use URI::Escape qw(uri_unescape);
 
 our $VERSION = "1.69";
 
 sub _uric_escape {
     my($class, $str) = @_;
     if ($str =~ m,^((?:$URI::scheme_re:)?)//([^/?\#]*)(.*)$,os) {
 	my($scheme, $host, $rest) = ($1, $2, $3);
 	my $ui = $host =~ s/(.*@)// ? $1 : "";
 	my $port = $host =~ s/(:\d+)\z// ? $1 : "";
 	if (_host_escape($host)) {
 	    $str = "$scheme//$ui$host$port$rest";
 	}
     }
     return $class->SUPER::_uric_escape($str);
 }
 
 sub _host_escape {
     return unless $_[0] =~ /[^$URI::uric]/;
     eval {
 	require URI::_idna;
 	$_[0] = URI::_idna::encode($_[0]);
     };
     return 0 if $@;
     return 1;
 }
 
 sub as_iri {
     my $self = shift;
     my $str = $self->SUPER::as_iri;
     if ($str =~ /\bxn--/) {
 	if ($str =~ m,^((?:$URI::scheme_re:)?)//([^/?\#]*)(.*)$,os) {
 	    my($scheme, $host, $rest) = ($1, $2, $3);
 	    my $ui = $host =~ s/(.*@)// ? $1 : "";
 	    my $port = $host =~ s/(:\d+)\z// ? $1 : "";
 	    require URI::_idna;
 	    $host = URI::_idna::decode($host);
 	    $str = "$scheme//$ui$host$port$rest";
 	}
     }
     return $str;
 }
 
 sub userinfo
 {
     my $self = shift;
     my $old = $self->authority;
 
     if (@_) {
 	my $new = $old;
 	$new = "" unless defined $new;
 	$new =~ s/.*@//;  
 	my $ui = shift;
 	if (defined $ui) {
 	    $ui =~ s/@/%40/g;   
 	    $new = "$ui\@$new";
 	}
 	$self->authority($new);
     }
     return undef if !defined($old) || $old !~ /(.*)@/;
     return $1;
 }
 
 sub host
 {
     my $self = shift;
     my $old = $self->authority;
     if (@_) {
 	my $tmp = $old;
 	$tmp = "" unless defined $tmp;
 	my $ui = ($tmp =~ /(.*@)/) ? $1 : "";
 	my $port = ($tmp =~ /(:\d+)$/) ? $1 : "";
 	my $new = shift;
 	$new = "" unless defined $new;
 	if (length $new) {
 	    $new =~ s/[@]/%40/g;   
 	    if ($new =~ /^[^:]*:\d*\z/ || $new =~ /]:\d*\z/) {
 		$new =~ s/(:\d*)\z// || die "Assert";
 		$port = $1;
 	    }
 	    $new = "[$new]" if $new =~ /:/ && $new !~ /^\[/; 
 	    _host_escape($new);
 	}
 	$self->authority("$ui$new$port");
     }
     return undef unless defined $old;
     $old =~ s/.*@//;
     $old =~ s/:\d+$//;          
     $old =~ s{^\[(.*)\]$}{$1};  
     return uri_unescape($old);
 }
 
 sub ihost
 {
     my $self = shift;
     my $old = $self->host(@_);
     if ($old =~ /(^|\.)xn--/) {
 	require URI::_idna;
 	$old = URI::_idna::decode($old);
     }
     return $old;
 }
 
 sub _port
 {
     my $self = shift;
     my $old = $self->authority;
     if (@_) {
 	my $new = $old;
 	$new =~ s/:\d*$//;
 	my $port = shift;
 	$new .= ":$port" if defined $port;
 	$self->authority($new);
     }
     return $1 if defined($old) && $old =~ /:(\d*)$/;
     return;
 }
 
 sub port
 {
     my $self = shift;
     my $port = $self->_port(@_);
     $port = $self->default_port if !defined($port) || $port eq "";
     $port;
 }
 
 sub host_port
 {
     my $self = shift;
     my $old = $self->authority;
     $self->host(shift) if @_;
     return undef unless defined $old;
     $old =~ s/.*@//;        
     $old =~ s/:$//;         
     $old .= ":" . $self->port unless $old =~ /:\d+$/;
     $old;
 }
 
 
 sub default_port { undef }
 
 sub canonical
 {
     my $self = shift;
     my $other = $self->SUPER::canonical;
     my $host = $other->host || "";
     my $port = $other->_port;
     my $uc_host = $host =~ /[A-Z]/;
     my $def_port = defined($port) && ($port eq "" ||
                                       $port == $self->default_port);
     if ($uc_host || $def_port) {
 	$other = $other->clone if $other == $self;
 	$other->host(lc $host) if $uc_host;
 	$other->port(undef)    if $def_port;
     }
     $other;
 }
 
 1;
### URI/_userpass.pm ###
 package URI::_userpass;
 
 use strict;
 use warnings;
 
 use URI::Escape qw(uri_unescape);
 
 our $VERSION = "1.69";
 
 sub user
 {
     my $self = shift;
     my $info = $self->userinfo;
     if (@_) {
 	my $new = shift;
 	my $pass = defined($info) ? $info : "";
 	$pass =~ s/^[^:]*//;
 
 	if (!defined($new) && !length($pass)) {
 	    $self->userinfo(undef);
 	} else {
 	    $new = "" unless defined($new);
 	    $new =~ s/%/%25/g;
 	    $new =~ s/:/%3A/g;
 	    $self->userinfo("$new$pass");
 	}
     }
     return undef unless defined $info;
     $info =~ s/:.*//;
     uri_unescape($info);
 }
 
 sub password
 {
     my $self = shift;
     my $info = $self->userinfo;
     if (@_) {
 	my $new = shift;
 	my $user = defined($info) ? $info : "";
 	$user =~ s/:.*//;
 
 	if (!defined($new) && !length($user)) {
 	    $self->userinfo(undef);
 	} else {
 	    $new = "" unless defined($new);
 	    $new =~ s/%/%25/g;
 	    $self->userinfo("$user:$new");
 	}
     }
     return undef unless defined $info;
     return undef unless $info =~ s/^[^:]*://;
     uri_unescape($info);
 }
 
 1;
### URI/data.pm ###
 package URI::data;  
 
 use strict;
 use warnings;
 
 use parent 'URI';
 
 our $VERSION = '1.69';
 
 use MIME::Base64 qw(encode_base64 decode_base64);
 use URI::Escape  qw(uri_unescape);
 
 sub media_type
 {
     my $self = shift;
     my $opaque = $self->opaque;
     $opaque =~ /^([^,]*),?/ or die;
     my $old = $1;
     my $base64;
     $base64 = $1 if $old =~ s/(;base64)$//i;
     if (@_) {
 	my $new = shift;
 	$new = "" unless defined $new;
 	$new =~ s/%/%25/g;
 	$new =~ s/,/%2C/g;
 	$base64 = "" unless defined $base64;
 	$opaque =~ s/^[^,]*,?/$new$base64,/;
 	$self->opaque($opaque);
     }
     return uri_unescape($old) if $old;  
     "text/plain;charset=US-ASCII";      
 }
 
 sub data
 {
     my $self = shift;
     my($enc, $data) = split(",", $self->opaque, 2);
     unless (defined $data) {
 	$data = "";
 	$enc  = "" unless defined $enc;
     }
     my $base64 = ($enc =~ /;base64$/i);
     if (@_) {
 	$enc =~ s/;base64$//i if $base64;
 	my $new = shift;
 	$new = "" unless defined $new;
 	my $uric_count = _uric_count($new);
 	my $urienc_len = $uric_count + (length($new) - $uric_count) * 3;
 	my $base64_len = int((length($new)+2) / 3) * 4;
 	$base64_len += 7;  
 	if ($base64_len < $urienc_len || $_[0]) {
 	    $enc .= ";base64";
 	    $new = encode_base64($new, "");
 	} else {
 	    $new =~ s/%/%25/g;
 	}
 	$self->opaque("$enc,$new");
     }
     return unless defined wantarray;
     $data = uri_unescape($data);
     return $base64 ? decode_base64($data) : $data;
 }
 
 my $ENC = $URI::uric;
 $ENC =~ s/%//;
 
 eval <<EOT; die $@ if $@;
 sub _uric_count
 {
     \$_[0] =~ tr/$ENC//;
 }
 EOT
 
 1;
 
 __END__
 
### URI/file.pm ###
 package URI::file;
 
 use strict;
 use warnings;
 
 use parent 'URI::_generic';
 our $VERSION = "4.21";
 
 use URI::Escape qw(uri_unescape);
 
 our $DEFAULT_AUTHORITY = "";
 
 our %OS_CLASS = (
      os2     => "OS2",
      mac     => "Mac",
      MacOS   => "Mac",
      MSWin32 => "Win32",
      win32   => "Win32",
      msdos   => "FAT",
      dos     => "FAT",
      qnx     => "QNX",
 );
 
 sub os_class
 {
     my($OS) = shift || $^O;
 
     my $class = "URI::file::" . ($OS_CLASS{$OS} || "Unix");
     no strict 'refs';
     unless (%{"$class\::"}) {
 	eval "require $class";
 	die $@ if $@;
     }
     $class;
 }
 
 sub host { uri_unescape(shift->authority(@_)) }
 
 sub new
 {
     my($class, $path, $os) = @_;
     os_class($os)->new($path);
 }
 
 sub new_abs
 {
     my $class = shift;
     my $file = $class->new(@_);
     return $file->abs($class->cwd) unless $$file =~ /^file:/;
     $file;
 }
 
 sub cwd
 {
     my $class = shift;
     require Cwd;
     my $cwd = Cwd::cwd();
     $cwd = VMS::Filespec::unixpath($cwd) if $^O eq 'VMS';
     $cwd = $class->new($cwd);
     $cwd .= "/" unless substr($cwd, -1, 1) eq "/";
     $cwd;
 }
 
 sub canonical {
     my $self = shift;
     my $other = $self->SUPER::canonical;
 
     my $scheme = $other->scheme;
     my $auth = $other->authority;
     return $other if !defined($scheme) && !defined($auth);  
 
     if (!defined($auth) ||
 	$auth eq "" ||
 	lc($auth) eq "localhost" ||
 	(defined($DEFAULT_AUTHORITY) && lc($auth) eq lc($DEFAULT_AUTHORITY))
        )
     {
 	if ((defined($auth) || defined($DEFAULT_AUTHORITY)) &&
 	    (!defined($auth) || !defined($DEFAULT_AUTHORITY) || $auth ne $DEFAULT_AUTHORITY)
 	   )
 	{
 	    $other = $other->clone if $self == $other;
 	    $other->authority($DEFAULT_AUTHORITY);
         }
     }
 
     $other;
 }
 
 sub file
 {
     my($self, $os) = @_;
     os_class($os)->file($self);
 }
 
 sub dir
 {
     my($self, $os) = @_;
     os_class($os)->dir($self);
 }
 
 1;
 
 __END__
 
 
 
 RFC 1630
 
    [...]
 
    There is clearly a danger of confusion that a link made to a local
    file should be followed by someone on a different system, with
    unexpected and possibly harmful results.  Therefore, the convention
    is that even a "file" URL is provided with a host part.  This allows
    a client on another system to know that it cannot access the file
    system, or perhaps to use some other local mechanism to access the
    file.
 
    The special value "localhost" is used in the host field to indicate
    that the filename should really be used on whatever host one is.
    This for example allows links to be made to files which are
    distributed on many machines, or to "your unix local password file"
    subject of course to consistency across the users of the data.
 
    A void host field is equivalent to "localhost".
 
### URI/file/Base.pm ###
 package URI::file::Base;
 
 use strict;
 use warnings;
 
 use URI::Escape qw();
 
 our $VERSION = "1.69";
 
 sub new
 {
     my $class = shift;
     my $path  = shift;
     $path = "" unless defined $path;
 
     my($auth, $escaped_auth, $escaped_path);
 
     ($auth, $escaped_auth) = $class->_file_extract_authority($path);
     ($path, $escaped_path) = $class->_file_extract_path($path);
 
     if (defined $auth) {
 	$auth =~ s,%,%25,g unless $escaped_auth;
 	$auth =~ s,([/?\#]), URI::Escape::escape_char($1),eg;
 	$auth = "//$auth";
 	if (defined $path) {
 	    $path = "/$path" unless substr($path, 0, 1) eq "/";
 	} else {
 	    $path = "";
 	}
     } else {
 	return undef unless defined $path;
 	$auth = "";
     }
 
     $path =~ s,([%;?]), URI::Escape::escape_char($1),eg unless $escaped_path;
     $path =~ s/\#/%23/g;
 
     my $uri = $auth . $path;
     $uri = "file:$uri" if substr($uri, 0, 1) eq "/";
 
     URI->new($uri, "file");
 }
 
 sub _file_extract_authority
 {
     my($class, $path) = @_;
     return undef unless $class->_file_is_absolute($path);
     return $URI::file::DEFAULT_AUTHORITY;
 }
 
 sub _file_extract_path
 {
     return undef;
 }
 
 sub _file_is_absolute
 {
     return 0;
 }
 
 sub _file_is_localhost
 {
     shift; 
     my $host = lc(shift);
     return 1 if $host eq "localhost";
     eval {
 	require Net::Domain;
 	lc(Net::Domain::hostfqdn()) eq $host ||
 	lc(Net::Domain::hostname()) eq $host;
     };
 }
 
 sub file
 {
     undef;
 }
 
 sub dir
 {
     my $self = shift;
     $self->file(@_);
 }
 
 1;
### URI/file/FAT.pm ###
 package URI::file::FAT;
 
 use strict;
 use warnings;
 
 use parent 'URI::file::Win32';
 
 our $VERSION = "1.69";
 
 sub fix_path
 {
     shift; 
     for (@_) {
 	my @p = map uc, split(/\./, $_, -1);
 	return if @p > 2;     
 	@p = ("") unless @p;  
 	$_ = substr($p[0], 0, 8);
         if (@p > 1) {
 	    my $ext = substr($p[1], 0, 3);
 	    $_ .= ".$ext" if length $ext;
 	}
     }
     1;  
 }
 
 1;
### URI/file/Mac.pm ###
 package URI::file::Mac;
 
 use strict;
 use warnings;
 
 use parent 'URI::file::Base';
 
 use URI::Escape qw(uri_unescape);
 
 our $VERSION = "1.69";
 
 sub _file_extract_path
 {
     my $class = shift;
     my $path = shift;
 
     my @pre;
     if ($path =~ s/^(:+)//) {
 	if (length($1) == 1) {
 	    @pre = (".") unless length($path);
 	} else {
 	    @pre = ("..") x (length($1) - 1);
 	}
     } else { 
 	$pre[0] = "";
     }
 
     my $isdir = ($path =~ s/:$//);
     $path =~ s,([%/;]), URI::Escape::escape_char($1),eg;
 
     my @path = split(/:/, $path, -1);
     for (@path) {
 	if ($_ eq "." || $_ eq "..") {
 	    $_ = "%2E" x length($_);
 	}
 	$_ = ".." unless length($_);
     }
     push (@path,"") if $isdir;
     (join("/", @pre, @path), 1);
 }
 
 
 sub file
 {
     my $class = shift;
     my $uri = shift;
     my @path;
 
     my $auth = $uri->authority;
     if (defined $auth) {
 	if (lc($auth) ne "localhost" && $auth ne "") {
 	    my $u_auth = uri_unescape($auth);
 	    if (!$class->_file_is_localhost($u_auth)) {
 		@path = ("", $auth);
 	    }
 	}
     }
     my @ps = split("/", $uri->path, -1);
     shift @ps if @path;
     push(@path, @ps);
 
     my $pre = "";
     if (!@path) {
 	return;  
     } elsif ($path[0] eq "") {
 	shift(@path);
 	if (@path == 1) {
 	    return if $path[0] eq "";  
 	    push(@path, "");           
 	}
 	@ps = @path;
 	@path = ();
         my $part;
 	for (@ps) {  
 	    next if $_ eq ".";
 	    $part = $_ eq ".." ? "" : $_;
 	    push(@path,$part);
 	}
 	if ($ps[-1] eq "..") {  
 	    push(@path,"");
 	}
 	
     } else {
 	$pre = ":";
 	@ps = @path;
 	@path = ();
         my $part;
 	for (@ps) {  
 	    next if $_ eq ".";
 	    $part = $_ eq ".." ? "" : $_;
 	    push(@path,$part);
 	}
 	if ($ps[-1] eq "..") {  
 	    push(@path,"");
 	}
 	
     }
     return unless $pre || @path;
     for (@path) {
 	s/;.*//;  
 	$_ = uri_unescape($_);
 	return if /\0/;
 	return if /:/;  
     }
     $pre . join(":", @path);
 }
 
 sub dir
 {
     my $class = shift;
     my $path = $class->file(@_);
     return unless defined $path;
     $path .= ":" unless $path =~ /:$/;
     $path;
 }
 
 1;
### URI/file/OS2.pm ###
 package URI::file::OS2;
 
 use strict;
 use warnings;
 
 use parent 'URI::file::Win32';
 
 our $VERSION = "1.69";
 
 
 sub _file_extract_authority
 {
     my $class = shift;
     return $1 if $_[0] =~ s,^\\\\([^\\]+),,;  
     return $1 if $_[0] =~ s,^//([^/]+),,;     
 
     if ($_[0] =~ m#^[a-zA-Z]{1,2}:#) {	      
 	return "";
     }
     return;
 }
 
 sub file {
   my $p = &URI::file::Win32::file;
   return unless defined $p;
   $p =~ s,\\,/,g;
   $p;
 }
 
 1;
### URI/file/QNX.pm ###
 package URI::file::QNX;
 
 use strict;
 use warnings;
 
 use parent 'URI::file::Unix';
 
 our $VERSION = "1.69";
 
 sub _file_extract_path
 {
     my($class, $path) = @_;
     $path =~ s,(.)//+,$1/,g; 
     $path =~ s,(/\.)+/,/,g;
     $path = "./$path" if $path =~ m,^[^:/]+:,,; 
     $path;
 }
 
 1;
### URI/file/Unix.pm ###
 package URI::file::Unix;
 
 use strict;
 use warnings;
 
 use parent 'URI::file::Base';
 
 use URI::Escape qw(uri_unescape);
 
 our $VERSION = "1.69";
 
 sub _file_extract_path
 {
     my($class, $path) = @_;
 
     $path =~ s,//+,/,g;
     $path =~ s,(/\.)+/,/,g;
     $path = "./$path" if $path =~ m,^[^:/]+:,,; 
 
     return $path;
 }
 
 sub _file_is_absolute {
     my($class, $path) = @_;
     return $path =~ m,^/,;
 }
 
 sub file
 {
     my $class = shift;
     my $uri = shift;
     my @path;
 
     my $auth = $uri->authority;
     if (defined($auth)) {
 	if (lc($auth) ne "localhost" && $auth ne "") {
 	    $auth = uri_unescape($auth);
 	    unless ($class->_file_is_localhost($auth)) {
 		push(@path, "", "", $auth);
 	    }
 	}
     }
 
     my @ps = $uri->path_segments;
     shift @ps if @path;
     push(@path, @ps);
 
     for (@path) {
 	return undef if /\0/;
 	return undef if /\//;  
     }
 
     return join("/", @path);
 }
 
 1;
### URI/file/Win32.pm ###
 package URI::file::Win32;
 
 use strict;
 use warnings;
 
 use parent 'URI::file::Base';
 
 use URI::Escape qw(uri_unescape);
 
 our $VERSION = "1.69";
 
 sub _file_extract_authority
 {
     my $class = shift;
 
     return $class->SUPER::_file_extract_authority($_[0])
 	if defined $URI::file::DEFAULT_AUTHORITY;
 
     return $1 if $_[0] =~ s,^\\\\([^\\]+),,;  
     return $1 if $_[0] =~ s,^//([^/]+),,;     
 
     if ($_[0] =~ s,^([a-zA-Z]:),,) {
 	my $auth = $1;
 	$auth .= "relative" if $_[0] !~ m,^[\\/],;
 	return $auth;
     }
     return undef;
 }
 
 sub _file_extract_path
 {
     my($class, $path) = @_;
     $path =~ s,\\,/,g;
     $path =~ s,(/\.)+/,/,g;
 
     if (defined $URI::file::DEFAULT_AUTHORITY) {
 	$path =~ s,^([a-zA-Z]:),/$1,;
     }
 
     return $path;
 }
 
 sub _file_is_absolute {
     my($class, $path) = @_;
     return $path =~ m,^[a-zA-Z]:, || $path =~ m,^[/\\],;
 }
 
 sub file
 {
     my $class = shift;
     my $uri = shift;
     my $auth = $uri->authority;
     my $rel; 
     if (defined $auth) {
         $auth = uri_unescape($auth);
 	if ($auth =~ /^([a-zA-Z])[:|](relative)?/) {
 	    $auth = uc($1) . ":";
 	    $rel++ if $2;
 	} elsif (lc($auth) eq "localhost") {
 	    $auth = "";
 	} elsif (length $auth) {
 	    $auth = "\\\\" . $auth;  
 	}
     } else {
 	$auth = "";
     }
 
     my @path = $uri->path_segments;
     for (@path) {
 	return undef if /\0/;
 	return undef if /\//;
     }
     return undef unless $class->fix_path(@path);
 
     my $path = join("\\", @path);
     $path =~ s/^\\// if $rel;
     $path = $auth . $path;
     $path =~ s,^\\([a-zA-Z])[:|],\u$1:,;
 
     return $path;
 }
 
 sub fix_path { 1; }
 
 1;
### URI/ftp.pm ###
 package URI::ftp;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent qw(URI::_server URI::_userpass);
 
 sub default_port { 21 }
 
 sub path { shift->path_query(@_) }  
 
 sub _user     { shift->SUPER::user(@_);     }
 sub _password { shift->SUPER::password(@_); }
 
 sub user
 {
     my $self = shift;
     my $user = $self->_user(@_);
     $user = "anonymous" unless defined $user;
     $user;
 }
 
 sub password
 {
     my $self = shift;
     my $pass = $self->_password(@_);
     unless (defined $pass) {
 	my $user = $self->user;
 	if ($user eq 'anonymous' || $user eq 'ftp') {
 	    $pass = 'anonymous@';
 	}
     }
     $pass;
 }
 
 1;
### URI/gopher.pm ###
 package URI::gopher;  
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::_server';
 
 use URI::Escape qw(uri_unescape);
 
 
 sub default_port { 70 }
 
 sub _gopher_type
 {
     my $self = shift;
     my $path = $self->path_query;
     $path =~ s,^/,,;
     my $gtype = $1 if $path =~ s/^(.)//s;
     if (@_) {
 	my $new_type = shift;
 	if (defined($new_type)) {
 	    Carp::croak("Bad gopher type '$new_type'")
                unless length($new_type) == 1;
 	    substr($path, 0, 0) = $new_type;
 	    $self->path_query($path);
 	} else {
 	    Carp::croak("Can't delete gopher type when selector is present")
 		if length($path);
 	    $self->path_query(undef);
 	}
     }
     return $gtype;
 }
 
 sub gopher_type
 {
     my $self = shift;
     my $gtype = $self->_gopher_type(@_);
     $gtype = "1" unless defined $gtype;
     $gtype;
 }
 
 sub gtype { goto &gopher_type }  
 
 sub selector { shift->_gfield(0, @_) }
 sub search   { shift->_gfield(1, @_) }
 sub string   { shift->_gfield(2, @_) }
 
 sub _gfield
 {
     my $self = shift;
     my $fno  = shift;
     my $path = $self->path_query;
 
     $path =~ s/\?/\t/;
     $path = uri_unescape($path);
     $path =~ s,^/,,;
     my $gtype = $1 if $path =~ s,^(.),,s;
     my @path = split(/\t/, $path, 3);
     if (@_) {
 	my $new = shift;
 	$path[$fno] = $new;
 	pop(@path) while @path && !defined($path[-1]);
 	for (@path) { $_="" unless defined }
 	$path = $gtype;
 	$path = "1" unless defined $path;
 	$path .= join("\t", @path);
 	$self->path_query($path);
     }
     $path[$fno];
 }
 
 1;
### URI/http.pm ###
 package URI::http;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::_server';
 
 sub default_port { 80 }
 
 sub canonical
 {
     my $self = shift;
     my $other = $self->SUPER::canonical;
 
     my $slash_path = defined($other->authority) &&
         !length($other->path) && !defined($other->query);
 
     if ($slash_path) {
 	$other = $other->clone if $other == $self;
 	$other->path("/");
     }
     $other;
 }
 
 1;
### URI/https.pm ###
 package URI::https;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::http';
 
 sub default_port { 443 }
 
 sub secure { 1 }
 
 1;
### URI/ldap.pm ###
 
 package URI::ldap;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent qw(URI::_ldap URI::_server);
 
 sub default_port { 389 }
 
 sub _nonldap_canonical {
     my $self = shift;
     $self->URI::_server::canonical(@_);
 }
 
 1;
 
 __END__
 
### URI/ldapi.pm ###
 package URI::ldapi;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent qw(URI::_ldap URI::_generic);
 
 require URI::Escape;
 
 sub un_path {
     my $self = shift;
     my $old = URI::Escape::uri_unescape($self->authority);
     if (@_) {
 	my $p = shift;
 	$p =~ s/:/%3A/g;
 	$p =~ s/\@/%40/g;
 	$self->authority($p);
     }
     return $old;
 }
 
 sub _nonldap_canonical {
     my $self = shift;
     $self->URI::_generic::canonical(@_);
 }
 
 1;
### URI/ldaps.pm ###
 package URI::ldaps;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::ldap';
 
 sub default_port { 636 }
 
 sub secure { 1 }
 
 1;
### URI/mailto.pm ###
 package URI::mailto;  
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent qw(URI URI::_query);
 
 sub to
 {
     my $self = shift;
     my @old = $self->headers;
     if (@_) {
 	my @new = @old;
 	for (my $i = 0; $i < @new; $i += 2) {
 	    if (lc($new[$i] || '') eq "to") {
 		splice(@new, $i, 2);
 		redo;
 	    }
 	}
 
 	my $to = shift;
 	$to = "" unless defined $to;
 	unshift(@new, "to" => $to);
 	$self->headers(@new);
     }
     return unless defined wantarray;
 
     my @to;
     while (@old) {
 	my $h = shift @old;
 	my $v = shift @old;
 	push(@to, $v) if lc($h) eq "to";
     }
     join(",", @to);
 }
 
 
 sub headers
 {
     my $self = shift;
 
     my $opaque = "to=" . $self->opaque;
     $opaque =~ s/\?/&/;
 
     if (@_) {
 	my @new = @_;
 
 	my @to;
 	for (my $i=0; $i < @new; $i += 2) {
 	    if (lc($new[$i] || '') eq "to") {
 		push(@to, (splice(@new, $i, 2))[1]);  
 		redo;
 	    }
 	}
 
 	my $new = join(",",@to);
 	$new =~ s/%/%25/g;
 	$new =~ s/\?/%3F/g;
 	$self->opaque($new);
 	$self->query_form(@new) if @new;
     }
     return unless defined wantarray;
 
     URI->new("mailto:?$opaque")->query_form;
 }
 
 1;
### URI/mms.pm ###
 package URI::mms;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::http';
 
 sub default_port { 1755 }
 
 1;
### URI/news.pm ###
 package URI::news;  
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::_server';
 
 use URI::Escape qw(uri_unescape);
 use Carp ();
 
 sub default_port { 119 }
 
 
 sub _group
 {
     my $self = shift;
     my $old = $self->path;
     if (@_) {
 	my($group,$from,$to) = @_;
 	if ($group =~ /\@/) {
             $group =~ s/^<(.*)>$/$1/;  
 	}
 	$group =~ s,%,%25,g;
 	$group =~ s,/,%2F,g;
 	my $path = $group;
 	if (defined $from) {
 	    $path .= "/$from";
 	    $path .= "-$to" if defined $to;
 	}
 	$self->path($path);
     }
 
     $old =~ s,^/,,;
     if ($old !~ /\@/ && $old =~ s,/(.*),, && wantarray) {
 	my $extra = $1;
 	return (uri_unescape($old), split(/-/, $extra));
     }
     uri_unescape($old);
 }
 
 
 sub group
 {
     my $self = shift;
     if (@_) {
 	Carp::croak("Group name can't contain '\@'") if $_[0] =~ /\@/;
     }
     my @old = $self->_group(@_);
     return if $old[0] =~ /\@/;
     wantarray ? @old : $old[0];
 }
 
 sub message
 {
     my $self = shift;
     if (@_) {
 	Carp::croak("Message must contain '\@'") unless $_[0] =~ /\@/;
     }
     my $old = $self->_group(@_);
     return undef unless $old =~ /\@/;
     return $old;
 }
 
 1;
### URI/nntp.pm ###
 package URI::nntp;  
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::news';
 
 1;
### URI/pop.pm ###
 package URI::pop;   
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::_server';
 
 use URI::Escape qw(uri_unescape);
 
 sub default_port { 110 }
 
 
 sub user
 {
     my $self = shift;
     my $old = $self->userinfo;
 
     if (@_) {
 	my $new_info = $old;
 	$new_info = "" unless defined $new_info;
 	$new_info =~ s/^[^;]*//;
 
 	my $new = shift;
 	if (!defined($new) && !length($new_info)) {
 	    $self->userinfo(undef);
 	} else {
 	    $new = "" unless defined $new;
 	    $new =~ s/%/%25/g;
 	    $new =~ s/;/%3B/g;
 	    $self->userinfo("$new$new_info");
 	}
     }
 
     return undef unless defined $old;
     $old =~ s/;.*//;
     return uri_unescape($old);
 }
 
 sub auth
 {
     my $self = shift;
     my $old = $self->userinfo;
 
     if (@_) {
 	my $new = $old;
 	$new = "" unless defined $new;
 	$new =~ s/(^[^;]*)//;
 	my $user = $1;
 	$new =~ s/;auth=[^;]*//i;
 
 	
 	my $auth = shift;
 	if (defined $auth) {
 	    $auth =~ s/%/%25/g;
 	    $auth =~ s/;/%3B/g;
 	    $new = ";AUTH=$auth$new";
 	}
 	$self->userinfo("$user$new");
 	
     }
 
     return undef unless defined $old;
     $old =~ s/^[^;]*//;
     return uri_unescape($1) if $old =~ /;auth=(.*)/i;
     return;
 }
 
 1;
### URI/rlogin.pm ###
 package URI::rlogin;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::_login';
 
 sub default_port { 513 }
 
 1;
### URI/rsync.pm ###
 package URI::rsync;  
 
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent qw(URI::_server URI::_userpass);
 
 sub default_port { 873 }
 
 1;
### URI/rtsp.pm ###
 package URI::rtsp;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::http';
 
 sub default_port { 554 }
 
 1;
### URI/rtspu.pm ###
 package URI::rtspu;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::rtsp';
 
 sub default_port { 554 }
 
 1;
### URI/sftp.pm ###
 package URI::sftp;
 
 use strict;
 use warnings;
 
 use parent 'URI::ssh';
 
 our $VERSION = "1.69";
 
 1;
### URI/sip.pm ###
 
 package URI::sip;
 
 use strict;
 use warnings;
 
 use parent qw(URI::_server URI::_userpass);
 
 use URI::Escape qw(uri_unescape);
 
 our $VERSION = "1.69";
 
 sub default_port { 5060 }
 
 sub authority
 {
     my $self = shift;
     $$self =~ m,^($URI::scheme_re:)?([^;?]*)(.*)$,os or die;
     my $old = $2;
 
     if (@_) {
         my $auth = shift;
         $$self = defined($1) ? $1 : "";
         my $rest = $3;
         if (defined $auth) {
             $auth =~ s/([^$URI::uric])/ URI::Escape::escape_char($1)/ego;
             $$self .= "$auth";
         }
         $$self .= $rest;
     }
     $old;
 }
 
 sub params_form
 {
     my $self = shift;
     $$self =~ m,^((?:$URI::scheme_re:)?)(?:([^;?]*))?(;[^?]*)?(.*)$,os or die;
     my $paramstr = $3;
 
     if (@_) {
     	my @args = @_; 
         $$self = $1 . $2;
         my $rest = $4;
 	my @new;
 	for (my $i=0; $i < @args; $i += 2) {
 	    push(@new, "$args[$i]=$args[$i+1]");
 	}
 	$paramstr = join(";", @new);
 	$$self .= ";" . $paramstr . $rest;
     }
     $paramstr =~ s/^;//o;
     return split(/[;=]/, $paramstr);
 }
 
 sub params
 {
     my $self = shift;
     $$self =~ m,^((?:$URI::scheme_re:)?)(?:([^;?]*))?(;[^?]*)?(.*)$,os or die;
     my $paramstr = $3;
 
     if (@_) {
     	my $new = shift; 
         $$self = $1 . $2;
         my $rest = $4;
 	$$self .= $paramstr . $rest;
     }
     $paramstr =~ s/^;//o;
     return $paramstr;
 }
 
 sub path {}
 sub path_query {}
 sub path_segments {}
 sub abs { shift }
 sub rel { shift }
 sub query_keywords {}
 
 1;
### URI/sips.pm ###
 package URI::sips;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::sip';
 
 sub default_port { 5061 }
 
 sub secure { 1 }
 
 1;
### URI/snews.pm ###
 package URI::snews;  
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::news';
 
 sub default_port { 563 }
 
 sub secure { 1 }
 
 1;
### URI/ssh.pm ###
 package URI::ssh;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::_login';
 
 
 sub default_port { 22 }
 
 sub secure { 1 }
 
 1;
### URI/telnet.pm ###
 package URI::telnet;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::_login';
 
 sub default_port { 23 }
 
 1;
### URI/tn3270.pm ###
 package URI::tn3270;
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::_login';
 
 sub default_port { 23 }
 
 1;
### URI/urn.pm ###
 package URI::urn;  
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI';
 
 use Carp qw(carp);
 
 my %implementor;
 
 sub _init {
     my $class = shift;
     my $self = $class->SUPER::_init(@_);
     my $nid = $self->nid;
 
     my $impclass = $implementor{$nid};
     return $impclass->_urn_init($self, $nid) if $impclass;
 
     $impclass = "URI::urn";
     if ($nid =~ /^[A-Za-z\d][A-Za-z\d\-]*\z/) {
 	my $id = $nid;
 	$id =~ s/-/_/g;
 	$id = "_$id" if $id =~ /^\d/;
 
 	$impclass = "URI::urn::$id";
 	no strict 'refs';
 	unless (@{"${impclass}::ISA"}) {
 	    eval "require $impclass";
 	    die $@ if $@ && $@ !~ /Can\'t locate.*in \@INC/;
 	    $impclass = "URI::urn" unless @{"${impclass}::ISA"};
 	}
     }
     else {
 	carp("Illegal namespace identifier '$nid' for URN '$self'") if $^W;
     }
     $implementor{$nid} = $impclass;
 
     return $impclass->_urn_init($self, $nid);
 }
 
 sub _urn_init {
     my($class, $self, $nid) = @_;
     bless $self, $class;
 }
 
 sub _nid {
     my $self = shift;
     my $opaque = $self->opaque;
     if (@_) {
 	my $v = $opaque;
 	my $new = shift;
 	$v =~ s/[^:]*/$new/;
 	$self->opaque($v);
     }
     $opaque =~ s/:.*//s;
     return $opaque;
 }
 
 sub nid {  
     my $self = shift;
     my $nid = $self->_nid(@_);
     $nid = lc($nid) if defined($nid);
     return $nid;
 }
 
 sub nss {  
     my $self = shift;
     my $opaque = $self->opaque;
     if (@_) {
 	my $v = $opaque;
 	my $new = shift;
 	if (defined $new) {
 	    $v =~ s/(:|\z).*/:$new/;
 	}
 	else {
 	    $v =~ s/:.*//s;
 	}
 	$self->opaque($v);
     }
     return undef unless $opaque =~ s/^[^:]*://;
     return $opaque;
 }
 
 sub canonical {
     my $self = shift;
     my $nid = $self->_nid;
     my $new = $self->SUPER::canonical;
     return $new if $nid !~ /[A-Z]/ || $nid =~ /%/;
     $new = $new->clone if $new == $self;
     $new->nid(lc($nid));
     return $new;
 }
 
 1;
### URI/urn/isbn.pm ###
 package URI::urn::isbn;  
 
 use strict;
 use warnings;
 
 use parent 'URI::urn';
 
 use Carp qw(carp);
 
 BEGIN {
     require Business::ISBN;
     
     local $^W = 0; 
     warn "Using Business::ISBN version " . Business::ISBN->VERSION . 
         " which is deprecated.\nUpgrade to Business::ISBN version 2\n"
         if Business::ISBN->VERSION < 2;
     }
     
 sub _isbn {
     my $nss = shift;
     $nss = $nss->nss if ref($nss);
     my $isbn = Business::ISBN->new($nss);
     $isbn = undef if $isbn && !$isbn->is_valid;
     return $isbn;
 }
 
 sub _nss_isbn {
     my $self = shift;
     my $nss = $self->nss(@_);
     my $isbn = _isbn($nss);
     $isbn = $isbn->as_string if $isbn;
     return($nss, $isbn);
 }
 
 sub isbn {
     my $self = shift;
     my $isbn;
     (undef, $isbn) = $self->_nss_isbn(@_);
     return $isbn;
 }
 
 sub isbn_publisher_code {
     my $isbn = shift->_isbn || return undef;
     return $isbn->publisher_code;
 }
 
 BEGIN {
 my $group_method = do {
     local $^W = 0; 
     Business::ISBN->VERSION >= 2 ? 'group_code' : 'country_code';
     };
 
 sub isbn_group_code {
     my $isbn = shift->_isbn || return undef;
     return $isbn->$group_method;
 }
 }
 
 sub isbn_country_code {
     my $name = (caller(0))[3]; $name =~ s/.*:://;
     carp "$name is DEPRECATED. Use isbn_group_code instead";
     
     no strict 'refs';
     &isbn_group_code;
 }
 
 BEGIN {
 my $isbn13_method = do {
     local $^W = 0; 
     Business::ISBN->VERSION >= 2 ? 'as_isbn13' : 'as_ean';
     };
 
 sub isbn13 {
     my $isbn = shift->_isbn || return undef;
     
     my $thingy = $isbn->$isbn13_method;
     return eval { $thingy->can( 'as_string' ) } ? $thingy->as_string([]) : $thingy;
 }
 }
 
 sub isbn_as_ean {
     my $name = (caller(0))[3]; $name =~ s/.*:://;
     carp "$name is DEPRECATED. Use isbn13 instead";
 
     no strict 'refs';
     &isbn13;
 }
 
 sub canonical {
     my $self = shift;
     my($nss, $isbn) = $self->_nss_isbn;
     my $new = $self->SUPER::canonical;
     return $new unless $nss && $isbn && $nss ne $isbn;
     $new = $new->clone if $new == $self;
     $new->nss($isbn);
     return $new;
 }
 
 1;
### URI/urn/oid.pm ###
 package URI::urn::oid;  
 
 use strict;
 use warnings;
 
 our $VERSION = "1.69";
 
 use parent 'URI::urn';
 
 sub oid {
     my $self = shift;
     my $old = $self->nss;
     if (@_) {
 	$self->nss(join(".", @_));
     }
     return split(/\./, $old) if wantarray;
     return $old;
 }
 
 1;
### UUID/Random.pm ###
 package UUID::Random;
 
 require 5.006_001;
 use strict;
 use warnings;
 
 
 our $VERSION = '0.04';
 
 sub generate {
   my @chars = ('a'..'f',0..9);
   my @string;
   push(@string, $chars[int(rand(16))]) for(1..32);
   splice(@string,8,0,'-');
   splice(@string,13,0,'-');
   splice(@string,18,0,'-');
   splice(@string,23,0,'-');
   return join('', @string);
 }
 
 1;
 __END__
 
### Version/Util.pm ###
 package Version::Util;
 
 use 5.010001;
 use strict;
 use version 0.77;
 use warnings;
 
 require Exporter;
 our @ISA = qw(Exporter);
 our @EXPORT_OK = qw(
                        cmp_version
                        version_eq version_ne
                        version_lt version_le version_gt version_ge
                        version_between version_in
                );
 
 our $VERSION = '0.71'; 
 
 sub cmp_version {
     version->parse($_[0]) <=> version->parse($_[1]);
 }
 
 sub version_eq {
     version->parse($_[0]) == version->parse($_[1]);
 }
 
 sub version_ne {
     version->parse($_[0]) != version->parse($_[1]);
 }
 
 sub version_lt {
     version->parse($_[0]) <  version->parse($_[1]);
 }
 
 sub version_le {
     version->parse($_[0]) <= version->parse($_[1]);
 }
 
 sub version_gt {
     version->parse($_[0]) >  version->parse($_[1]);
 }
 
 sub version_ge {
     version->parse($_[0]) >= version->parse($_[1]);
 }
 
 sub version_between {
     my $v = version->parse(shift);
     while (@_) {
         my $v1 = shift;
         my $v2 = shift;
         return 1 if $v >= version->parse($v1) && $v <= version->parse($v2);
     }
     0;
 }
 
 sub version_in {
     my $v = version->parse(shift);
     for (@_) {
         return 1 if $v == version->parse($_);
     }
     0;
 }
 
 1;
 
 __END__
 
### YAML.pm ###
 package YAML;
 our $VERSION = '1.15';
 
 use YAML::Mo;
 
 use Exporter;
 push @YAML::ISA, 'Exporter';
 our @EXPORT = qw{ Dump Load };
 our @EXPORT_OK = qw{ freeze thaw DumpFile LoadFile Bless Blessed };
 
 use YAML::Node; 
 
 use constant VALUE => "\x07YAML\x07VALUE\x07";
 
 has dumper_class => default => sub {'YAML::Dumper'};
 has loader_class => default => sub {'YAML::Loader'};
 has dumper_object => default => sub {$_[0]->init_action_object("dumper")};
 has loader_object => default => sub {$_[0]->init_action_object("loader")};
 
 sub Dump {
     my $yaml = YAML->new;
     $yaml->dumper_class($YAML::DumperClass)
         if $YAML::DumperClass;
     return $yaml->dumper_object->dump(@_);
 }
 
 sub Load {
     my $yaml = YAML->new;
     $yaml->loader_class($YAML::LoaderClass)
         if $YAML::LoaderClass;
     return $yaml->loader_object->load(@_);
 }
 
 {
     no warnings 'once';
     *freeze = \ &Dump;
     *thaw   = \ &Load;
 }
 
 sub DumpFile {
     my $OUT;
     my $filename = shift;
     if (ref $filename eq 'GLOB') {
         $OUT = $filename;
     }
     else {
         my $mode = '>';
         if ($filename =~ /^\s*(>{1,2})\s*(.*)$/) {
             ($mode, $filename) = ($1, $2);
         }
         open $OUT, $mode, $filename
           or YAML::Mo::Object->die('YAML_DUMP_ERR_FILE_OUTPUT', $filename, $!);
     }
     binmode $OUT, ':utf8';  
     local $/ = "\n"; 
     print $OUT Dump(@_);
 }
 
 sub LoadFile {
     my $IN;
     my $filename = shift;
     if (ref $filename eq 'GLOB') {
         $IN = $filename;
     }
     else {
         open $IN, '<', $filename
           or YAML::Mo::Object->die('YAML_LOAD_ERR_FILE_INPUT', $filename, $!);
     }
     binmode $IN, ':utf8';  
     return Load(do { local $/; <$IN> });
 }
 
 sub init_action_object {
     my $self = shift;
     my $object_class = (shift) . '_class';
     my $module_name = $self->$object_class;
     eval "require $module_name";
     $self->die("Error in require $module_name - $@")
         if $@ and "$@" !~ /Can't locate/;
     my $object = $self->$object_class->new;
     $object->set_global_options;
     return $object;
 }
 
 my $global = {};
 sub Bless {
     require YAML::Dumper::Base;
     YAML::Dumper::Base::bless($global, @_)
 }
 sub Blessed {
     require YAML::Dumper::Base;
     YAML::Dumper::Base::blessed($global, @_)
 }
 sub global_object { $global }
 
 1;
### YAML/Any.pm ###
 use strict; use warnings;
 package YAML::Any;
 our $VERSION = '1.15';
 
 use Exporter ();
 
 @YAML::Any::ISA       = 'Exporter';
 @YAML::Any::EXPORT    = qw(Dump Load);
 @YAML::Any::EXPORT_OK = qw(DumpFile LoadFile);
 
 my @dump_options = qw(
     UseCode
     DumpCode
     SpecVersion
     Indent
     UseHeader
     UseVersion
     SortKeys
     AnchorPrefix
     UseBlock
     UseFold
     CompressSeries
     InlineSeries
     UseAliases
     Purity
     Stringify
 );
 
 my @load_options = qw(
     UseCode
     LoadCode
 );
 
 my @implementations = qw(
     YAML::XS
     YAML::Syck
     YAML::Old
     YAML
     YAML::Tiny
 );
 
 sub import {
     __PACKAGE__->implementation;
     goto &Exporter::import;
 }
 
 sub Dump {
     no strict 'refs';
     no warnings 'once';
     my $implementation = __PACKAGE__->implementation;
     for my $option (@dump_options) {
         my $var = "$implementation\::$option";
         my $value = $$var;
         local $$var;
         $$var = defined $value ? $value : ${"YAML::$option"};
     }
     return &{"$implementation\::Dump"}(@_);
 }
 
 sub DumpFile {
     no strict 'refs';
     no warnings 'once';
     my $implementation = __PACKAGE__->implementation;
     for my $option (@dump_options) {
         my $var = "$implementation\::$option";
         my $value = $$var;
         local $$var;
         $$var = defined $value ? $value : ${"YAML::$option"};
     }
     return &{"$implementation\::DumpFile"}(@_);
 }
 
 sub Load {
     no strict 'refs';
     no warnings 'once';
     my $implementation = __PACKAGE__->implementation;
     for my $option (@load_options) {
         my $var = "$implementation\::$option";
         my $value = $$var;
         local $$var;
         $$var = defined $value ? $value : ${"YAML::$option"};
     }
     return &{"$implementation\::Load"}(@_);
 }
 
 sub LoadFile {
     no strict 'refs';
     no warnings 'once';
     my $implementation = __PACKAGE__->implementation;
     for my $option (@load_options) {
         my $var = "$implementation\::$option";
         my $value = $$var;
         local $$var;
         $$var = defined $value ? $value : ${"YAML::$option"};
     }
     return &{"$implementation\::LoadFile"}(@_);
 }
 
 sub order {
     return @YAML::Any::_TEST_ORDER
         if @YAML::Any::_TEST_ORDER;
     return @implementations;
 }
 
 sub implementation {
     my @order = __PACKAGE__->order;
     for my $module (@order) {
         my $path = $module;
         $path =~ s/::/\//g;
         $path .= '.pm';
         return $module if exists $INC{$path};
         eval "require $module; 1" and return $module;
     }
     croak("YAML::Any couldn't find any of these YAML implementations: @order");
 }
 
 sub croak {
     require Carp;
     Carp::croak(@_);
 }
 
 1;
### YAML/Dumper.pm ###
 package YAML::Dumper;
 
 use YAML::Mo;
 extends 'YAML::Dumper::Base';
 
 use YAML::Dumper::Base;
 use YAML::Node;
 use YAML::Types;
 use Scalar::Util qw();
 
 use constant KEY       => 3;
 use constant BLESSED   => 4;
 use constant FROMARRAY => 5;
 use constant VALUE     => "\x07YAML\x07VALUE\x07";
 
 my $ESCAPE_CHAR = '[\\x00-\\x08\\x0b-\\x0d\\x0e-\\x1f]';
 my $LIT_CHAR    = '|';
 
 sub dump {
     my $self = shift;
     $self->stream('');
     $self->document(0);
     for my $document (@_) {
         $self->{document}++;
         $self->transferred({});
         $self->id_refcnt({});
         $self->id_anchor({});
         $self->anchor(1);
         $self->level(0);
         $self->offset->[0] = 0 - $self->indent_width;
         $self->_prewalk($document);
         $self->_emit_header($document);
         $self->_emit_node($document);
     }
     return $self->stream;
 }
 
 sub _emit_header {
     my $self = shift;
     my ($node) = @_;
     if (not $self->use_header and
         $self->document == 1
        ) {
         $self->die('YAML_DUMP_ERR_NO_HEADER')
           unless ref($node) =~ /^(HASH|ARRAY)$/;
         $self->die('YAML_DUMP_ERR_NO_HEADER')
           if ref($node) eq 'HASH' and keys(%$node) == 0;
         $self->die('YAML_DUMP_ERR_NO_HEADER')
           if ref($node) eq 'ARRAY' and @$node == 0;
         $self->headless(1);
         return;
     }
     $self->{stream} .= '---';
     if ($self->use_version) {
     }
 }
 
 sub _prewalk {
     my $self = shift;
     my $stringify = $self->stringify;
     my ($class, $type, $node_id) = $self->node_info(\$_[0], $stringify);
 
     if ($type eq 'GLOB') {
         $self->transferred->{$node_id} =
           YAML::Type::glob->yaml_dump($_[0]);
         $self->_prewalk($self->transferred->{$node_id});
         return;
     }
 
     if (ref($_[0]) eq 'Regexp') {
         return;
     }
 
     if (not ref $_[0]) {
         $self->{id_refcnt}{$node_id}++ if $self->purity;
         return;
     }
 
     my $value = $_[0];
     ($class, $type, $node_id) = $self->node_info($value, $stringify);
 
     return if (ref($value) and not $type);
 
     if ($self->transferred->{$node_id}) {
         (undef, undef, $node_id) = (ref $self->transferred->{$node_id})
           ? $self->node_info($self->transferred->{$node_id}, $stringify)
           : $self->node_info(\ $self->transferred->{$node_id}, $stringify);
         $self->{id_refcnt}{$node_id}++;
         return;
     }
 
     if ($type eq 'CODE') {
         $self->transferred->{$node_id} = 'placeholder';
         YAML::Type::code->yaml_dump(
             $self->dump_code,
             $_[0],
             $self->transferred->{$node_id}
         );
         ($class, $type, $node_id) =
           $self->node_info(\ $self->transferred->{$node_id}, $stringify);
         $self->{id_refcnt}{$node_id}++;
         return;
     }
 
     if (defined $class) {
         if ($value->can('yaml_dump')) {
             $value = $value->yaml_dump;
         }
         elsif ($type eq 'SCALAR') {
             $self->transferred->{$node_id} = 'placeholder';
             YAML::Type::blessed->yaml_dump
               ($_[0], $self->transferred->{$node_id});
             ($class, $type, $node_id) =
               $self->node_info(\ $self->transferred->{$node_id}, $stringify);
             $self->{id_refcnt}{$node_id}++;
             return;
         }
         else {
             $value = YAML::Type::blessed->yaml_dump($value);
         }
         $self->transferred->{$node_id} = $value;
         (undef, $type, $node_id) = $self->node_info($value, $stringify);
     }
 
     require YAML;
     if (defined YAML->global_object()->{blessed_map}{$node_id}) {
         $value = YAML->global_object()->{blessed_map}{$node_id};
         $self->transferred->{$node_id} = $value;
         ($class, $type, $node_id) = $self->node_info($value, $stringify);
         $self->_prewalk($value);
         return;
     }
 
     if ($type eq 'REF' or $type eq 'SCALAR') {
         $value = YAML::Type::ref->yaml_dump($value);
         $self->transferred->{$node_id} = $value;
         (undef, $type, $node_id) = $self->node_info($value, $stringify);
     }
 
     elsif ($type eq 'GLOB') {
         my $ref_ynode = $self->transferred->{$node_id} =
           YAML::Type::ref->yaml_dump($value);
 
         my $glob_ynode = $ref_ynode->{&VALUE} =
           YAML::Type::glob->yaml_dump($$value);
 
         (undef, undef, $node_id) = $self->node_info($glob_ynode, $stringify);
         $self->transferred->{$node_id} = $glob_ynode;
         $self->_prewalk($glob_ynode);
         return;
     }
 
     return if ++($self->{id_refcnt}{$node_id}) > 1;
 
     if ($type eq 'HASH') {
         $self->_prewalk($value->{$_})
             for keys %{$value};
         return;
     }
     elsif ($type eq 'ARRAY') {
         $self->_prewalk($_)
             for @{$value};
         return;
     }
 
     $self->warn(<<"...");
 YAML::Dumper can't handle dumping this type of data.
 Please report this to the author.
 
 id:    $node_id
 type:  $type
 class: $class
 value: $value
 
 ...
 
     return;
 }
 
 sub _emit_node {
     my $self = shift;
     my ($type, $node_id);
     my $ref = ref($_[0]);
     if ($ref) {
         if ($ref eq 'Regexp') {
             $self->_emit(' !!perl/regexp');
             $self->_emit_str("$_[0]");
             return;
         }
         (undef, $type, $node_id) = $self->node_info($_[0], $self->stringify);
     }
     else {
         $type = $ref || 'SCALAR';
         (undef, undef, $node_id) = $self->node_info(\$_[0], $self->stringify);
     }
 
     my ($ynode, $tag) = ('') x 2;
     my ($value, $context) = (@_, 0);
 
     if (defined $self->transferred->{$node_id}) {
         $value = $self->transferred->{$node_id};
         $ynode = ynode($value);
         if (ref $value) {
             $tag = defined $ynode ? $ynode->tag->short : '';
             (undef, $type, $node_id) =
               $self->node_info($value, $self->stringify);
         }
         else {
             $ynode = ynode($self->transferred->{$node_id});
             $tag = defined $ynode ? $ynode->tag->short : '';
             $type = 'SCALAR';
             (undef, undef, $node_id) =
               $self->node_info(
                   \ $self->transferred->{$node_id},
                   $self->stringify
               );
         }
     }
     elsif ($ynode = ynode($value)) {
         $tag = $ynode->tag->short;
     }
 
     if ($self->use_aliases) {
         $self->{id_refcnt}{$node_id} ||= 0;
         if ($self->{id_refcnt}{$node_id} > 1) {
             if (defined $self->{id_anchor}{$node_id}) {
                 $self->{stream} .= ' *' . $self->{id_anchor}{$node_id} . "\n";
                 return;
             }
             my $anchor = $self->anchor_prefix . $self->{anchor}++;
             $self->{stream} .= ' &' . $anchor;
             $self->{id_anchor}{$node_id} = $anchor;
         }
     }
 
     return $self->_emit_str("$value")   
       if ref($value) and not $type;
     return $self->_emit_scalar($value, $tag)
       if $type eq 'SCALAR' and $tag;
     return $self->_emit_str($value)
       if $type eq 'SCALAR';
     return $self->_emit_mapping($value, $tag, $node_id, $context)
       if $type eq 'HASH';
     return $self->_emit_sequence($value, $tag)
       if $type eq 'ARRAY';
     $self->warn('YAML_DUMP_WARN_BAD_NODE_TYPE', $type);
     return $self->_emit_str("$value");
 }
 
 sub _emit_mapping {
     my $self = shift;
     my ($value, $tag, $node_id, $context) = @_;
     $self->{stream} .= " !$tag" if $tag;
 
     my $empty_hash = not(eval {keys %$value});
     $self->warn('YAML_EMIT_WARN_KEYS', $@) if $@;
     return ($self->{stream} .= " {}\n") if $empty_hash;
 
     if ($context == FROMARRAY and
         $self->compress_series and
         not (defined $self->{id_anchor}{$node_id} or $tag or $empty_hash)
        ) {
         $self->{stream} .= ' ';
         $self->offset->[$self->level+1] = $self->offset->[$self->level] + 2;
     }
     else {
         $context = 0;
         $self->{stream} .= "\n"
           unless $self->headless && not($self->headless(0));
         $self->offset->[$self->level+1] =
           $self->offset->[$self->level] + $self->indent_width;
     }
 
     $self->{level}++;
     my @keys;
     if ($self->sort_keys == 1) {
         if (ynode($value)) {
             @keys = keys %$value;
         }
         else {
             @keys = sort keys %$value;
         }
     }
     elsif ($self->sort_keys == 2) {
         @keys = sort keys %$value;
     }
     elsif (ref($self->sort_keys) eq 'ARRAY') {
         my $i = 1;
         my %order = map { ($_, $i++) } @{$self->sort_keys};
         @keys = sort {
             (defined $order{$a} and defined $order{$b})
               ? ($order{$a} <=> $order{$b})
               : ($a cmp $b);
         } keys %$value;
     }
     else {
         @keys = keys %$value;
     }
     if (exists $value->{&VALUE}) {
         for (my $i = 0; $i < @keys; $i++) {
             if ($keys[$i] eq &VALUE) {
                 splice(@keys, $i, 1);
                 push @keys, &VALUE;
                 last;
             }
         }
     }
 
     for my $key (@keys) {
         $self->_emit_key($key, $context);
         $context = 0;
         $self->{stream} .= ':';
         $self->_emit_node($value->{$key});
     }
     $self->{level}--;
 }
 
 sub _emit_sequence {
     my $self = shift;
     my ($value, $tag) = @_;
     $self->{stream} .= " !$tag" if $tag;
 
     return ($self->{stream} .= " []\n") if @$value == 0;
 
     $self->{stream} .= "\n"
       unless $self->headless && not($self->headless(0));
 
     if ($self->inline_series and
         @$value <= $self->inline_series and
         not (scalar grep {ref or /\n/} @$value)
        ) {
         $self->{stream} =~ s/\n\Z/ /;
         $self->{stream} .= '[';
         for (my $i = 0; $i < @$value; $i++) {
             $self->_emit_str($value->[$i], KEY);
             last if $i == $#{$value};
             $self->{stream} .= ', ';
         }
         $self->{stream} .= "]\n";
         return;
     }
 
     $self->offset->[$self->level + 1] =
       $self->offset->[$self->level] + $self->indent_width;
     $self->{level}++;
     for my $val (@$value) {
         $self->{stream} .= ' ' x $self->offset->[$self->level];
         $self->{stream} .= '-';
         $self->_emit_node($val, FROMARRAY);
     }
     $self->{level}--;
 }
 
 sub _emit_key {
     my $self = shift;
     my ($value, $context) = @_;
     $self->{stream} .= ' ' x $self->offset->[$self->level]
       unless $context == FROMARRAY;
     $self->_emit_str($value, KEY);
 }
 
 sub _emit_scalar {
     my $self = shift;
     my ($value, $tag) = @_;
     $self->{stream} .= " !$tag";
     $self->_emit_str($value, BLESSED);
 }
 
 sub _emit {
     my $self = shift;
     $self->{stream} .= join '', @_;
 }
 
 sub _emit_str {
     my $self = shift;
     my $type = $_[1] || 0;
 
     $self->offset->[$self->level + 1] =
       $self->offset->[$self->level] + $self->indent_width;
     $self->{level}++;
 
     my $sf = $type == KEY ? '' : ' ';
     my $sb = $type == KEY ? '? ' : ' ';
     my $ef = $type == KEY ? '' : "\n";
     my $eb = "\n";
 
     while (1) {
         $self->_emit($sf),
         $self->_emit_plain($_[0]),
         $self->_emit($ef), last
           if not defined $_[0];
         $self->_emit($sf, '=', $ef), last
           if $_[0] eq VALUE;
         $self->_emit($sf),
         $self->_emit_double($_[0]),
         $self->_emit($ef), last
           if $_[0] =~ /$ESCAPE_CHAR/;
         if ($_[0] =~ /\n/) {
             $self->_emit($sb),
             $self->_emit_block($LIT_CHAR, $_[0]),
             $self->_emit($eb), last
               if $self->use_block;
               Carp::cluck "[YAML] \$UseFold is no longer supported"
               if $self->use_fold;
             $self->_emit($sf),
             $self->_emit_double($_[0]),
             $self->_emit($ef), last
               if length $_[0] <= 30;
             $self->_emit($sf),
             $self->_emit_double($_[0]),
             $self->_emit($ef), last
               if $_[0] !~ /\n\s*\S/;
             $self->_emit($sb),
             $self->_emit_block($LIT_CHAR, $_[0]),
             $self->_emit($eb), last;
         }
         $self->_emit($sf),
         $self->_emit_number($_[0]),
         $self->_emit($ef), last
           if $self->is_literal_number($_[0]);
         $self->_emit($sf),
         $self->_emit_plain($_[0]),
         $self->_emit($ef), last
           if $self->is_valid_plain($_[0]);
         $self->_emit($sf),
         $self->_emit_double($_[0]),
         $self->_emit($ef), last
           if $_[0] =~ /'/;
         $self->_emit($sf),
         $self->_emit_single($_[0]),
         $self->_emit($ef);
         last;
     }
 
     $self->{level}--;
 
     return;
 }
 
 sub is_literal_number {
     my $self = shift;
     return B::svref_2object(\$_[0])->FLAGS & (B::SVp_IOK | B::SVp_NOK)
             && 0 + $_[0] eq $_[0];
 }
 
 sub _emit_number {
     my $self = shift;
     return $self->_emit_plain($_[0]);
 }
 
 sub is_valid_plain {
     my $self = shift;
     return 0 unless length $_[0];
     return 0 if $self->quote_numeric_strings and Scalar::Util::looks_like_number($_[0]);
     return 0 if $_[0] =~ /^[\s\{\[\~\`\'\"\!\@\#\>\|\%\&\?\*\^]/;
     return 0 if $_[0] =~ /[\{\[\]\},]/;
     return 0 if $_[0] =~ /[:\-\?]\s/;
     return 0 if $_[0] =~ /\s#/;
     return 0 if $_[0] =~ /\:(\s|$)/;
     return 0 if $_[0] =~ /[\s\|\>]$/;
     return 0 if $_[0] eq '-';
     return 1;
 }
 
 sub _emit_block {
     my $self = shift;
     my ($indicator, $value) = @_;
     $self->{stream} .= $indicator;
     $value =~ /(\n*)\Z/;
     my $chomp = length $1 ? (length $1 > 1) ? '+' : '' : '-';
     $value = '~' if not defined $value;
     $self->{stream} .= $chomp;
     $self->{stream} .= $self->indent_width if $value =~ /^\s/;
     $self->{stream} .= $self->indent($value);
 }
 
 sub _emit_plain {
     my $self = shift;
     $self->{stream} .= defined $_[0] ? $_[0] : '~';
 }
 
 sub _emit_double {
     my $self = shift;
     (my $escaped = $self->escape($_[0])) =~ s/"/\\"/g;
     $self->{stream} .= qq{"$escaped"};
 }
 
 sub _emit_single {
     my $self = shift;
     my $item = shift;
     $item =~ s{'}{''}g;
     $self->{stream} .= "'$item'";
 }
 
 
 sub indent {
     my $self = shift;
     my ($text) = @_;
     return $text unless length $text;
     $text =~ s/\n\Z//;
     my $indent = ' ' x $self->offset->[$self->level];
     $text =~ s/^/$indent/gm;
     $text = "\n$text";
     return $text;
 }
 
 my @escapes = qw(\0   \x01 \x02 \x03 \x04 \x05 \x06 \a
                  \x08 \t   \n   \v   \f   \r   \x0e \x0f
                  \x10 \x11 \x12 \x13 \x14 \x15 \x16 \x17
                  \x18 \x19 \x1a \e   \x1c \x1d \x1e \x1f
                 );
 
 sub escape {
     my $self = shift;
     my ($text) = @_;
     $text =~ s/\\/\\\\/g;
     $text =~ s/([\x00-\x1f])/$escapes[ord($1)]/ge;
     return $text;
 }
 
 1;
### YAML/Dumper/Base.pm ###
 package YAML::Dumper::Base;
 
 use YAML::Mo;
 
 use YAML::Node;
 
 has spec_version    => default => sub {'1.0'};
 has indent_width    => default => sub {2};
 has use_header      => default => sub {1};
 has use_version     => default => sub {0};
 has sort_keys       => default => sub {1};
 has anchor_prefix   => default => sub {''};
 has dump_code       => default => sub {0};
 has use_block       => default => sub {0};
 has use_fold        => default => sub {0};
 has compress_series => default => sub {1};
 has inline_series   => default => sub {0};
 has use_aliases     => default => sub {1};
 has purity          => default => sub {0};
 has stringify       => default => sub {0};
 has quote_numeric_strings => default => sub {0};
 
 has stream      => default => sub {''};
 has document    => default => sub {0};
 has transferred => default => sub {{}};
 has id_refcnt   => default => sub {{}};
 has id_anchor   => default => sub {{}};
 has anchor      => default => sub {1};
 has level       => default => sub {0};
 has offset      => default => sub {[]};
 has headless    => default => sub {0};
 has blessed_map => default => sub {{}};
 
 sub set_global_options {
     my $self = shift;
     $self->spec_version($YAML::SpecVersion)
       if defined $YAML::SpecVersion;
     $self->indent_width($YAML::Indent)
       if defined $YAML::Indent;
     $self->use_header($YAML::UseHeader)
       if defined $YAML::UseHeader;
     $self->use_version($YAML::UseVersion)
       if defined $YAML::UseVersion;
     $self->sort_keys($YAML::SortKeys)
       if defined $YAML::SortKeys;
     $self->anchor_prefix($YAML::AnchorPrefix)
       if defined $YAML::AnchorPrefix;
     $self->dump_code($YAML::DumpCode || $YAML::UseCode)
       if defined $YAML::DumpCode or defined $YAML::UseCode;
     $self->use_block($YAML::UseBlock)
       if defined $YAML::UseBlock;
     $self->use_fold($YAML::UseFold)
       if defined $YAML::UseFold;
     $self->compress_series($YAML::CompressSeries)
       if defined $YAML::CompressSeries;
     $self->inline_series($YAML::InlineSeries)
       if defined $YAML::InlineSeries;
     $self->use_aliases($YAML::UseAliases)
       if defined $YAML::UseAliases;
     $self->purity($YAML::Purity)
       if defined $YAML::Purity;
     $self->stringify($YAML::Stringify)
       if defined $YAML::Stringify;
     $self->quote_numeric_strings($YAML::QuoteNumericStrings)
       if defined $YAML::QuoteNumericStrings;
 }
 
 sub dump {
     my $self = shift;
     $self->die('dump() not implemented in this class.');
 }
 
 sub blessed {
     my $self = shift;
     my ($ref) = @_;
     $ref = \$_[0] unless ref $ref;
     my (undef, undef, $node_id) = YAML::Mo::Object->node_info($ref);
     $self->{blessed_map}->{$node_id};
 }
 
 sub bless {
     my $self = shift;
     my ($ref, $blessing) = @_;
     my $ynode;
     $ref = \$_[0] unless ref $ref;
     my (undef, undef, $node_id) = YAML::Mo::Object->node_info($ref);
     if (not defined $blessing) {
         $ynode = YAML::Node->new($ref);
     }
     elsif (ref $blessing) {
         $self->die() unless ynode($blessing);
         $ynode = $blessing;
     }
     else {
         no strict 'refs';
         my $transfer = $blessing . "::yaml_dump";
         $self->die() unless defined &{$transfer};
         $ynode = &{$transfer}($ref);
         $self->die() unless ynode($ynode);
     }
     $self->{blessed_map}->{$node_id} = $ynode;
     my $object = ynode($ynode) or $self->die();
     return $object;
 }
 
 1;
### YAML/Error.pm ###
 package YAML::Error;
 
 use YAML::Mo;
 
 has 'code';
 has 'type' => default => sub {'Error'};
 has 'line';
 has 'document';
 has 'arguments' => default => sub {[]};
 
 my ($error_messages, %line_adjust);
 
 sub format_message {
     my $self = shift;
     my $output = 'YAML ' . $self->type . ': ';
     my $code = $self->code;
     if ($error_messages->{$code}) {
         $code = sprintf($error_messages->{$code}, @{$self->arguments});
     }
     $output .= $code . "\n";
 
     $output .= '   Code: ' . $self->code . "\n"
         if defined $self->code;
     $output .= '   Line: ' . $self->line . "\n"
         if defined $self->line;
     $output .= '   Document: ' . $self->document . "\n"
         if defined $self->document;
     return $output;
 }
 
 sub error_messages {
     $error_messages;
 }
 
 %$error_messages = map {s/^\s+//;$_} split "\n", <<'...';
 YAML_PARSE_ERR_BAD_CHARS
   Invalid characters in stream. This parser only supports printable ASCII
 YAML_PARSE_ERR_BAD_MAJOR_VERSION
   Can't parse a %s document with a 1.0 parser
 YAML_PARSE_WARN_BAD_MINOR_VERSION
   Parsing a %s document with a 1.0 parser
 YAML_PARSE_WARN_MULTIPLE_DIRECTIVES
   '%s directive used more than once'
 YAML_PARSE_ERR_TEXT_AFTER_INDICATOR
   No text allowed after indicator
 YAML_PARSE_ERR_NO_ANCHOR
   No anchor for alias '*%s'
 YAML_PARSE_ERR_NO_SEPARATOR
   Expected separator '---'
 YAML_PARSE_ERR_SINGLE_LINE
   Couldn't parse single line value
 YAML_PARSE_ERR_BAD_ANCHOR
   Invalid anchor
 YAML_DUMP_ERR_INVALID_INDENT
   Invalid Indent width specified: '%s'
 YAML_LOAD_USAGE
   usage: YAML::Load($yaml_stream_scalar)
 YAML_PARSE_ERR_BAD_NODE
   Can't parse node
 YAML_PARSE_ERR_BAD_EXPLICIT
   Unsupported explicit transfer: '%s'
 YAML_DUMP_USAGE_DUMPCODE
   Invalid value for DumpCode: '%s'
 YAML_LOAD_ERR_FILE_INPUT
   Couldn't open %s for input:\n%s
 YAML_DUMP_ERR_FILE_CONCATENATE
   Can't concatenate to YAML file %s
 YAML_DUMP_ERR_FILE_OUTPUT
   Couldn't open %s for output:\n%s
 YAML_DUMP_ERR_NO_HEADER
   With UseHeader=0, the node must be a plain hash or array
 YAML_DUMP_WARN_BAD_NODE_TYPE
   Can't perform serialization for node type: '%s'
 YAML_EMIT_WARN_KEYS
   Encountered a problem with 'keys':\n%s
 YAML_DUMP_WARN_DEPARSE_FAILED
   Deparse failed for CODE reference
 YAML_DUMP_WARN_CODE_DUMMY
   Emitting dummy subroutine for CODE reference
 YAML_PARSE_ERR_MANY_EXPLICIT
   More than one explicit transfer
 YAML_PARSE_ERR_MANY_IMPLICIT
   More than one implicit request
 YAML_PARSE_ERR_MANY_ANCHOR
   More than one anchor
 YAML_PARSE_ERR_ANCHOR_ALIAS
   Can't define both an anchor and an alias
 YAML_PARSE_ERR_BAD_ALIAS
   Invalid alias
 YAML_PARSE_ERR_MANY_ALIAS
   More than one alias
 YAML_LOAD_ERR_NO_CONVERT
   Can't convert implicit '%s' node to explicit '%s' node
 YAML_LOAD_ERR_NO_DEFAULT_VALUE
   No default value for '%s' explicit transfer
 YAML_LOAD_ERR_NON_EMPTY_STRING
   Only the empty string can be converted to a '%s'
 YAML_LOAD_ERR_BAD_MAP_TO_SEQ
   Can't transfer map as sequence. Non numeric key '%s' encountered.
 YAML_DUMP_ERR_BAD_GLOB
   '%s' is an invalid value for Perl glob
 YAML_DUMP_ERR_BAD_REGEXP
   '%s' is an invalid value for Perl Regexp
 YAML_LOAD_ERR_BAD_MAP_ELEMENT
   Invalid element in map
 YAML_LOAD_WARN_DUPLICATE_KEY
   Duplicate map key found. Ignoring.
 YAML_LOAD_ERR_BAD_SEQ_ELEMENT
   Invalid element in sequence
 YAML_PARSE_ERR_INLINE_MAP
   Can't parse inline map
 YAML_PARSE_ERR_INLINE_SEQUENCE
   Can't parse inline sequence
 YAML_PARSE_ERR_BAD_DOUBLE
   Can't parse double quoted string
 YAML_PARSE_ERR_BAD_SINGLE
   Can't parse single quoted string
 YAML_PARSE_ERR_BAD_INLINE_IMPLICIT
   Can't parse inline implicit value '%s'
 YAML_PARSE_ERR_BAD_IMPLICIT
   Unrecognized implicit value '%s'
 YAML_PARSE_ERR_INDENTATION
   Error. Invalid indentation level
 YAML_PARSE_ERR_INCONSISTENT_INDENTATION
   Inconsistent indentation level
 YAML_LOAD_WARN_UNRESOLVED_ALIAS
   Can't resolve alias *%s
 YAML_LOAD_WARN_NO_REGEXP_IN_REGEXP
   No 'REGEXP' element for Perl regexp
 YAML_LOAD_WARN_BAD_REGEXP_ELEM
   Unknown element '%s' in Perl regexp
 YAML_LOAD_WARN_GLOB_NAME
   No 'NAME' element for Perl glob
 YAML_LOAD_WARN_PARSE_CODE
   Couldn't parse Perl code scalar: %s
 YAML_LOAD_WARN_CODE_DEPARSE
   Won't parse Perl code unless $YAML::LoadCode is set
 YAML_EMIT_ERR_BAD_LEVEL
   Internal Error: Bad level detected
 YAML_PARSE_WARN_AMBIGUOUS_TAB
   Amibiguous tab converted to spaces
 YAML_LOAD_WARN_BAD_GLOB_ELEM
   Unknown element '%s' in Perl glob
 YAML_PARSE_ERR_ZERO_INDENT
   Can't use zero as an indentation width
 YAML_LOAD_WARN_GLOB_IO
   Can't load an IO filehandle. Yet!!!
 ...
 
 %line_adjust = map {($_, 1)}
   qw(YAML_PARSE_ERR_BAD_MAJOR_VERSION
      YAML_PARSE_WARN_BAD_MINOR_VERSION
      YAML_PARSE_ERR_TEXT_AFTER_INDICATOR
      YAML_PARSE_ERR_NO_ANCHOR
      YAML_PARSE_ERR_MANY_EXPLICIT
      YAML_PARSE_ERR_MANY_IMPLICIT
      YAML_PARSE_ERR_MANY_ANCHOR
      YAML_PARSE_ERR_ANCHOR_ALIAS
      YAML_PARSE_ERR_BAD_ALIAS
      YAML_PARSE_ERR_MANY_ALIAS
      YAML_LOAD_ERR_NO_CONVERT
      YAML_LOAD_ERR_NO_DEFAULT_VALUE
      YAML_LOAD_ERR_NON_EMPTY_STRING
      YAML_LOAD_ERR_BAD_MAP_TO_SEQ
      YAML_LOAD_ERR_BAD_STR_TO_INT
      YAML_LOAD_ERR_BAD_STR_TO_DATE
      YAML_LOAD_ERR_BAD_STR_TO_TIME
      YAML_LOAD_WARN_DUPLICATE_KEY
      YAML_PARSE_ERR_INLINE_MAP
      YAML_PARSE_ERR_INLINE_SEQUENCE
      YAML_PARSE_ERR_BAD_DOUBLE
      YAML_PARSE_ERR_BAD_SINGLE
      YAML_PARSE_ERR_BAD_INLINE_IMPLICIT
      YAML_PARSE_ERR_BAD_IMPLICIT
      YAML_LOAD_WARN_NO_REGEXP_IN_REGEXP
      YAML_LOAD_WARN_BAD_REGEXP_ELEM
      YAML_LOAD_WARN_REGEXP_CREATE
      YAML_LOAD_WARN_GLOB_NAME
      YAML_LOAD_WARN_PARSE_CODE
      YAML_LOAD_WARN_CODE_DEPARSE
      YAML_LOAD_WARN_BAD_GLOB_ELEM
      YAML_PARSE_ERR_ZERO_INDENT
     );
 
 package YAML::Warning;
 
 our @ISA = 'YAML::Error';
 
 1;
### YAML/Loader.pm ###
 package YAML::Loader;
 
 use YAML::Mo;
 extends 'YAML::Loader::Base';
 
 use YAML::Loader::Base;
 use YAML::Types;
 
 use constant LEAF       => 1;
 use constant COLLECTION => 2;
 use constant VALUE      => "\x07YAML\x07VALUE\x07";
 use constant COMMENT    => "\x07YAML\x07COMMENT\x07";
 
 my $ESCAPE_CHAR = '[\\x00-\\x08\\x0b-\\x0d\\x0e-\\x1f]';
 my $FOLD_CHAR   = '>';
 my $LIT_CHAR    = '|';
 my $LIT_CHAR_RX = "\\$LIT_CHAR";
 
 sub load {
     my $self = shift;
     $self->stream($_[0] || '');
     return $self->_parse();
 }
 
 sub _parse {
     my $self = shift;
     my (%directives, $preface);
     $self->{stream} =~ s|\015\012|\012|g;
     $self->{stream} =~ s|\015|\012|g;
     $self->line(0);
     $self->die('YAML_PARSE_ERR_BAD_CHARS')
       if $self->stream =~ /$ESCAPE_CHAR/;
     $self->{stream} =~ s/(.)\n\Z/$1/s;
     $self->lines([split /\x0a/, $self->stream, -1]);
     $self->line(1);
     $self->_parse_throwaway_comments();
     $self->document(0);
     $self->documents([]);
     if (not $self->eos) {
         if ($self->lines->[0] !~ /^---(\s|$)/) {
             unshift @{$self->lines}, '---';
             $self->{line}--;
         }
     }
 
     while (not $self->eos) {
         $self->anchor2node({});
         $self->{document}++;
         $self->done(0);
         $self->level(0);
         $self->offset->[0] = -1;
 
         if ($self->lines->[0] =~ /^---\s*(.*)$/) {
             my @words = split /\s+/, $1;
             %directives = ();
             while (@words && $words[0] =~ /^#(\w+):(\S.*)$/) {
                 my ($key, $value) = ($1, $2);
                 shift(@words);
                 if (defined $directives{$key}) {
                     $self->warn('YAML_PARSE_WARN_MULTIPLE_DIRECTIVES',
                       $key, $self->document);
                     next;
                 }
                 $directives{$key} = $value;
             }
             $self->preface(join ' ', @words);
         }
         else {
             $self->die('YAML_PARSE_ERR_NO_SEPARATOR');
         }
 
         if (not $self->done) {
             $self->_parse_next_line(COLLECTION);
         }
         if ($self->done) {
             $self->{indent} = -1;
             $self->content('');
         }
 
         $directives{YAML} ||= '1.0';
         $directives{TAB} ||= 'NONE';
         ($self->{major_version}, $self->{minor_version}) =
           split /\./, $directives{YAML}, 2;
         $self->die('YAML_PARSE_ERR_BAD_MAJOR_VERSION', $directives{YAML})
           if $self->major_version ne '1';
         $self->warn('YAML_PARSE_WARN_BAD_MINOR_VERSION', $directives{YAML})
           if $self->minor_version ne '0';
         $self->die('Unrecognized TAB policy')
           unless $directives{TAB} =~ /^(NONE|\d+)(:HARD)?$/;
 
         push @{$self->documents}, $self->_parse_node();
     }
     return wantarray ? @{$self->documents} : $self->documents->[-1];
 }
 
 sub _parse_node {
     my $self = shift;
     my $preface = $self->preface;
     $self->preface('');
     my ($node, $type, $indicator, $escape, $chomp) = ('') x 5;
     my ($anchor, $alias, $explicit, $implicit, $class) = ('') x 5;
     ($anchor, $alias, $explicit, $implicit, $preface) =
       $self->_parse_qualifiers($preface);
     if ($anchor) {
         $self->anchor2node->{$anchor} = CORE::bless [], 'YAML-anchor2node';
     }
     $self->inline('');
     while (length $preface) {
         my $line = $self->line - 1;
         if ($preface =~ s/^($FOLD_CHAR|$LIT_CHAR_RX)(-|\+)?\d*\s*//) {
             $indicator = $1;
             $chomp = $2 if defined($2);
         }
         else {
             $self->die('YAML_PARSE_ERR_TEXT_AFTER_INDICATOR') if $indicator;
             $self->inline($preface);
             $preface = '';
         }
     }
     if ($alias) {
         $self->die('YAML_PARSE_ERR_NO_ANCHOR', $alias)
           unless defined $self->anchor2node->{$alias};
         if (ref($self->anchor2node->{$alias}) ne 'YAML-anchor2node') {
             $node = $self->anchor2node->{$alias};
         }
         else {
             $node = do {my $sv = "*$alias"};
             push @{$self->anchor2node->{$alias}}, [\$node, $self->line];
         }
     }
     elsif (length $self->inline) {
         $node = $self->_parse_inline(1, $implicit, $explicit);
         if (length $self->inline) {
             $self->die('YAML_PARSE_ERR_SINGLE_LINE');
         }
     }
     elsif ($indicator eq $LIT_CHAR) {
         $self->{level}++;
         $node = $self->_parse_block($chomp);
         $node = $self->_parse_implicit($node) if $implicit;
         $self->{level}--;
     }
     elsif ($indicator eq $FOLD_CHAR) {
         $self->{level}++;
         $node = $self->_parse_unfold($chomp);
         $node = $self->_parse_implicit($node) if $implicit;
         $self->{level}--;
     }
     else {
         $self->{level}++;
         $self->offset->[$self->level] ||= 0;
         if ($self->indent == $self->offset->[$self->level]) {
             if ($self->content =~ /^-( |$)/) {
                 $node = $self->_parse_seq($anchor);
             }
             elsif ($self->content =~ /(^\?|\:( |$))/) {
                 $node = $self->_parse_mapping($anchor);
             }
             elsif ($preface =~ /^\s*$/) {
                 $node = $self->_parse_implicit('');
             }
             else {
                 $self->die('YAML_PARSE_ERR_BAD_NODE');
             }
         }
         else {
             $node = undef;
         }
         $self->{level}--;
     }
     $#{$self->offset} = $self->level;
 
     if ($explicit) {
         if ($class) {
             if (not ref $node) {
                 my $copy = $node;
                 undef $node;
                 $node = \$copy;
             }
             CORE::bless $node, $class;
         }
         else {
             $node = $self->_parse_explicit($node, $explicit);
         }
     }
     if ($anchor) {
         if (ref($self->anchor2node->{$anchor}) eq 'YAML-anchor2node') {
             for my $ref (@{$self->anchor2node->{$anchor}}) {
                 ${$ref->[0]} = $node;
                 $self->warn('YAML_LOAD_WARN_UNRESOLVED_ALIAS',
                     $anchor, $ref->[1]);
             }
         }
         $self->anchor2node->{$anchor} = $node;
     }
     return $node;
 }
 
 sub _parse_qualifiers {
     my $self = shift;
     my ($preface) = @_;
     my ($anchor, $alias, $explicit, $implicit, $token) = ('') x 5;
     $self->inline('');
     while ($preface =~ /^[&*!]/) {
         my $line = $self->line - 1;
         if ($preface =~ s/^\!(\S+)\s*//) {
             $self->die('YAML_PARSE_ERR_MANY_EXPLICIT') if $explicit;
             $explicit = $1;
         }
         elsif ($preface =~ s/^\!\s*//) {
             $self->die('YAML_PARSE_ERR_MANY_IMPLICIT') if $implicit;
             $implicit = 1;
         }
         elsif ($preface =~ s/^\&([^ ,:]+)\s*//) {
             $token = $1;
             $self->die('YAML_PARSE_ERR_BAD_ANCHOR')
               unless $token =~ /^[a-zA-Z0-9]+$/;
             $self->die('YAML_PARSE_ERR_MANY_ANCHOR') if $anchor;
             $self->die('YAML_PARSE_ERR_ANCHOR_ALIAS') if $alias;
             $anchor = $token;
         }
         elsif ($preface =~ s/^\*([^ ,:]+)\s*//) {
             $token = $1;
             $self->die('YAML_PARSE_ERR_BAD_ALIAS')
               unless $token =~ /^[a-zA-Z0-9]+$/;
             $self->die('YAML_PARSE_ERR_MANY_ALIAS') if $alias;
             $self->die('YAML_PARSE_ERR_ANCHOR_ALIAS') if $anchor;
             $alias = $token;
         }
     }
     return ($anchor, $alias, $explicit, $implicit, $preface);
 }
 
 sub _parse_explicit {
     my $self = shift;
     my ($node, $explicit) = @_;
     my ($type, $class);
     if ($explicit =~ /^\!?perl\/(hash|array|ref|scalar)(?:\:(\w(\w|\:\:)*)?)?$/) {
         ($type, $class) = (($1 || ''), ($2 || ''));
 
 
         if ( $type eq "ref" ) {
             $self->die('YAML_LOAD_ERR_NO_DEFAULT_VALUE', 'XXX', $explicit)
             unless exists $node->{VALUE()} and scalar(keys %$node) == 1;
 
             my $value = $node->{VALUE()};
             $node = \$value;
         }
 
         if ( $type eq "scalar" and length($class) and !ref($node) ) {
             my $value = $node;
             $node = \$value;
         }
 
         if ( length($class) ) {
             CORE::bless($node, $class);
         }
 
         return $node;
     }
     if ($explicit =~ m{^!?perl/(glob|regexp|code)(?:\:(\w(\w|\:\:)*)?)?$}) {
         ($type, $class) = (($1 || ''), ($2 || ''));
         my $type_class = "YAML::Type::$type";
         no strict 'refs';
         if ($type_class->can('yaml_load')) {
             return $type_class->yaml_load($node, $class, $self);
         }
         else {
             $self->die('YAML_LOAD_ERR_NO_CONVERT', 'XXX', $explicit);
         }
     }
     elsif ($YAML::TagClass->{$explicit} ||
            $explicit =~ m{^perl/(\@|\$)?([a-zA-Z](\w|::)+)$}
           ) {
         $class = $YAML::TagClass->{$explicit} || $2;
         if ($class->can('yaml_load')) {
             require YAML::Node;
             return $class->yaml_load(YAML::Node->new($node, $explicit));
         }
         else {
             if (ref $node) {
                 return CORE::bless $node, $class;
             }
             else {
                 return CORE::bless \$node, $class;
             }
         }
     }
     elsif (ref $node) {
         require YAML::Node;
         return YAML::Node->new($node, $explicit);
     }
     else {
         return $node;
     }
 }
 
 sub _parse_mapping {
     my $self = shift;
     my ($anchor) = @_;
     my $mapping = {};
     $self->anchor2node->{$anchor} = $mapping;
     my $key;
     while (not $self->done and $self->indent == $self->offset->[$self->level]) {
         if ($self->{content} =~ s/^\?\s*//) {
             $self->preface($self->content);
             $self->_parse_next_line(COLLECTION);
             $key = $self->_parse_node();
             $key = "$key";
         }
         elsif ($self->{content} =~ s/^\=\s*//) {
             $key = VALUE;
         }
         elsif ($self->{content} =~ s/^\=\s*//) {
             $key = COMMENT;
         }
         else {
             $self->inline($self->content);
             $key = $self->_parse_inline();
             $key = "$key";
             $self->content($self->inline);
             $self->inline('');
         }
 
         unless ($self->{content} =~ s/^:\s*//) {
             $self->die('YAML_LOAD_ERR_BAD_MAP_ELEMENT');
         }
         $self->preface($self->content);
         my $line = $self->line;
         $self->_parse_next_line(COLLECTION);
         my $value = $self->_parse_node();
         if (exists $mapping->{$key}) {
             $self->warn('YAML_LOAD_WARN_DUPLICATE_KEY');
         }
         else {
             $mapping->{$key} = $value;
         }
     }
     return $mapping;
 }
 
 sub _parse_seq {
     my $self = shift;
     my ($anchor) = @_;
     my $seq = [];
     $self->anchor2node->{$anchor} = $seq;
     while (not $self->done and $self->indent == $self->offset->[$self->level]) {
         if ($self->content =~ /^-(?: (.*))?$/) {
             $self->preface(defined($1) ? $1 : '');
         }
         else {
             $self->die('YAML_LOAD_ERR_BAD_SEQ_ELEMENT');
         }
         if ($self->preface =~ /^(\s*)(\w.*\:(?: |$).*)$/) {
             $self->indent($self->offset->[$self->level] + 2 + length($1));
             $self->content($2);
             $self->level($self->level + 1);
             $self->offset->[$self->level] = $self->indent;
             $self->preface('');
             push @$seq, $self->_parse_mapping('');
             $self->{level}--;
             $#{$self->offset} = $self->level;
         }
         else {
             $self->_parse_next_line(COLLECTION);
             push @$seq, $self->_parse_node();
         }
     }
     return $seq;
 }
 
 sub _parse_inline {
     my $self = shift;
     my ($top, $top_implicit, $top_explicit) = (@_, '', '', '');
     $self->{inline} =~ s/^\s*(.*)\s*$/$1/; 
     my ($node, $anchor, $alias, $explicit, $implicit) = ('') x 5;
     ($anchor, $alias, $explicit, $implicit, $self->{inline}) =
       $self->_parse_qualifiers($self->inline);
     if ($anchor) {
         $self->anchor2node->{$anchor} = CORE::bless [], 'YAML-anchor2node';
     }
     $implicit ||= $top_implicit;
     $explicit ||= $top_explicit;
     ($top_implicit, $top_explicit) = ('', '');
     if ($alias) {
         $self->die('YAML_PARSE_ERR_NO_ANCHOR', $alias)
           unless defined $self->anchor2node->{$alias};
         if (ref($self->anchor2node->{$alias}) ne 'YAML-anchor2node') {
             $node = $self->anchor2node->{$alias};
         }
         else {
             $node = do {my $sv = "*$alias"};
             push @{$self->anchor2node->{$alias}}, [\$node, $self->line];
         }
     }
     elsif ($self->inline =~ /^\{/) {
         $node = $self->_parse_inline_mapping($anchor);
     }
     elsif ($self->inline =~ /^\[/) {
         $node = $self->_parse_inline_seq($anchor);
     }
     elsif ($self->inline =~ /^"/) {
         $node = $self->_parse_inline_double_quoted();
         $node = $self->_unescape($node);
         $node = $self->_parse_implicit($node) if $implicit;
     }
     elsif ($self->inline =~ /^'/) {
         $node = $self->_parse_inline_single_quoted();
         $node = $self->_parse_implicit($node) if $implicit;
     }
     else {
         if ($top) {
             $node = $self->inline;
             $self->inline('');
         }
         else {
             $node = $self->_parse_inline_simple();
         }
         $node = $self->_parse_implicit($node) unless $explicit;
     }
     if ($explicit) {
         $node = $self->_parse_explicit($node, $explicit);
     }
     if ($anchor) {
         if (ref($self->anchor2node->{$anchor}) eq 'YAML-anchor2node') {
             for my $ref (@{$self->anchor2node->{$anchor}}) {
                 ${$ref->[0]} = $node;
                 $self->warn('YAML_LOAD_WARN_UNRESOLVED_ALIAS',
                     $anchor, $ref->[1]);
             }
         }
         $self->anchor2node->{$anchor} = $node;
     }
     return $node;
 }
 
 sub _parse_inline_mapping {
     my $self = shift;
     my ($anchor) = @_;
     my $node = {};
     $self->anchor2node->{$anchor} = $node;
 
     $self->die('YAML_PARSE_ERR_INLINE_MAP')
       unless $self->{inline} =~ s/^\{\s*//;
     while (not $self->{inline} =~ s/^\s*\}//) {
         my $key = $self->_parse_inline();
         $self->die('YAML_PARSE_ERR_INLINE_MAP')
           unless $self->{inline} =~ s/^\: \s*//;
         my $value = $self->_parse_inline();
         if (exists $node->{$key}) {
             $self->warn('YAML_LOAD_WARN_DUPLICATE_KEY');
         }
         else {
             $node->{$key} = $value;
         }
         next if $self->inline =~ /^\s*\}/;
         $self->die('YAML_PARSE_ERR_INLINE_MAP')
           unless $self->{inline} =~ s/^\,\s*//;
     }
     return $node;
 }
 
 sub _parse_inline_seq {
     my $self = shift;
     my ($anchor) = @_;
     my $node = [];
     $self->anchor2node->{$anchor} = $node;
 
     $self->die('YAML_PARSE_ERR_INLINE_SEQUENCE')
       unless $self->{inline} =~ s/^\[\s*//;
     while (not $self->{inline} =~ s/^\s*\]//) {
         my $value = $self->_parse_inline();
         push @$node, $value;
         next if $self->inline =~ /^\s*\]/;
         $self->die('YAML_PARSE_ERR_INLINE_SEQUENCE')
           unless $self->{inline} =~ s/^\,\s*//;
     }
     return $node;
 }
 
 sub _parse_inline_double_quoted {
     my $self = shift;
     my $node;
     if ($self->inline =~ /^"((?:(?:\\"|[^"]){0,32766}){0,32766})"\s*(.*)$/) {
         $node = $1;
         $self->inline($2);
         $node =~ s/\\"/"/g;
     }
     else {
         $self->die('YAML_PARSE_ERR_BAD_DOUBLE');
     }
     return $node;
 }
 
 
 sub _parse_inline_single_quoted {
     my $self = shift;
     my $node;
     if ($self->inline =~ /^'((?:(?:''|[^']){0,32766}){0,32766})'\s*(.*)$/) {
         $node = $1;
         $self->inline($2);
         $node =~ s/''/'/g;
     }
     else {
         $self->die('YAML_PARSE_ERR_BAD_SINGLE');
     }
     return $node;
 }
 
 sub _parse_inline_simple {
     my $self = shift;
     my $value;
     if ($self->inline =~ /^(|[^!@#%^&*].*?)(?=[\[\]\{\},]|, |: |- |:\s*$|$)/) {
         $value = $1;
         substr($self->{inline}, 0, length($1)) = '';
     }
     else {
         $self->die('YAML_PARSE_ERR_BAD_INLINE_IMPLICIT', $value);
     }
     return $value;
 }
 
 sub _parse_implicit {
     my $self = shift;
     my ($value) = @_;
     $value =~ s/\s*$//;
     return $value if $value eq '';
     return undef if $value =~ /^~$/;
     return $value
       unless $value =~ /^[\@\`]/ or
              $value =~ /^[\-\?]\s/;
     $self->die('YAML_PARSE_ERR_BAD_IMPLICIT', $value);
 }
 
 sub _parse_unfold {
     my $self = shift;
     my ($chomp) = @_;
     my $node = '';
     my $space = 0;
     while (not $self->done and $self->indent == $self->offset->[$self->level]) {
         $node .= $self->content. "\n";
         $self->_parse_next_line(LEAF);
     }
     $node =~ s/^(\S.*)\n(?=\S)/$1 /gm;
     $node =~ s/^(\S.*)\n(\n+\S)/$1$2/gm;
     $node =~ s/\n*\Z// unless $chomp eq '+';
     $node .= "\n" unless $chomp;
     return $node;
 }
 
 sub _parse_block {
     my $self = shift;
     my ($chomp) = @_;
     my $node = '';
     while (not $self->done and $self->indent == $self->offset->[$self->level]) {
         $node .= $self->content . "\n";
         $self->_parse_next_line(LEAF);
     }
     return $node if '+' eq $chomp;
     $node =~ s/\n*\Z/\n/;
     $node =~ s/\n\Z// if $chomp eq '-';
     return $node;
 }
 
 sub _parse_throwaway_comments {
     my $self = shift;
     while (@{$self->lines} and
            $self->lines->[0] =~ m{^\s*(\#|$)}
           ) {
         shift @{$self->lines};
         $self->{line}++;
     }
     $self->eos($self->{done} = not @{$self->lines});
 }
 
 sub _parse_next_line {
     my $self = shift;
     my ($type) = @_;
     my $level = $self->level;
     my $offset = $self->offset->[$level];
     $self->die('YAML_EMIT_ERR_BAD_LEVEL') unless defined $offset;
     shift @{$self->lines};
     $self->eos($self->{done} = not @{$self->lines});
     return if $self->eos;
     $self->{line}++;
 
     if ($self->preface =~
         qr/(?:^|\s)(?:$FOLD_CHAR|$LIT_CHAR_RX)(?:-|\+)?(\d*)\s*$/
        ) {
         $self->die('YAML_PARSE_ERR_ZERO_INDENT')
           if length($1) and $1 == 0;
         $type = LEAF;
         if (length($1)) {
             $self->offset->[$level + 1] = $offset + $1;
         }
         else {
             while (@{$self->lines} && ($self->lines->[0] =~ /^\s*#/)) {
                 $self->lines->[0] =~ /^( *)/;
                 last unless length($1) <= $offset;
                 shift @{$self->lines};
                 $self->{line}++;
             }
             $self->eos($self->{done} = not @{$self->lines});
             return if $self->eos;
             if ($self->lines->[0] =~ /^( *)\S/ and length($1) > $offset) {
                 $self->offset->[$level+1] = length($1);
             }
             else {
                 $self->offset->[$level+1] = $offset + 1;
             }
         }
         $offset = $self->offset->[++$level];
     }
     elsif ($type == COLLECTION and
            $self->preface =~ /^(\s*(\!\S*|\&\S+))*\s*$/) {
         $self->_parse_throwaway_comments();
         if ($self->eos) {
             $self->offset->[$level+1] = $offset + 1;
             return;
         }
         else {
             $self->lines->[0] =~ /^( *)\S/ or
                 $self->die('YAML_PARSE_ERR_NONSPACE_INDENTATION');
             if (length($1) > $offset) {
                 $self->offset->[$level+1] = length($1);
             }
             else {
                 $self->offset->[$level+1] = $offset + 1;
             }
         }
         $offset = $self->offset->[++$level];
     }
 
     if ($type == LEAF) {
         while (@{$self->lines} and
                $self->lines->[0] =~ m{^( *)(\#)} and
                length($1) < $offset
               ) {
             shift @{$self->lines};
             $self->{line}++;
         }
         $self->eos($self->{done} = not @{$self->lines});
     }
     else {
         $self->_parse_throwaway_comments();
     }
     return if $self->eos;
 
     if ($self->lines->[0] =~ /^---(\s|$)/) {
         $self->done(1);
         return;
     }
     if ($type == LEAF and
         $self->lines->[0] =~ /^ {$offset}(.*)$/
        ) {
         $self->indent($offset);
         $self->content($1);
     }
     elsif ($self->lines->[0] =~ /^\s*$/) {
         $self->indent($offset);
         $self->content('');
     }
     else {
         $self->lines->[0] =~ /^( *)(\S.*)$/;
         while ($self->offset->[$level] > length($1)) {
             $level--;
         }
         $self->die('YAML_PARSE_ERR_INCONSISTENT_INDENTATION')
           if $self->offset->[$level] != length($1);
         $self->indent(length($1));
         $self->content($2);
     }
     $self->die('YAML_PARSE_ERR_INDENTATION')
       if $self->indent - $offset > 1;
 }
 
 
 my %unescapes = (
    0 => "\x00",
    a => "\x07",
    t => "\x09",
    n => "\x0a",
    'v' => "\x0b", 
    f => "\x0c",
    r => "\x0d",
    e => "\x1b",
    '\\' => '\\',
   );
 
 sub _unescape {
     my $self = shift;
     my ($node) = @_;
     $node =~ s/\\([never\\fart0]|x([0-9a-fA-F]{2}))/
               (length($1)>1)?pack("H2",$2):$unescapes{$1}/gex;
     return $node;
 }
 
 1;
### YAML/Loader/Base.pm ###
 package YAML::Loader::Base;
 
 use YAML::Mo;
 
 has load_code     => default => sub {0};
 has stream        => default => sub {''};
 has document      => default => sub {0};
 has line          => default => sub {0};
 has documents     => default => sub {[]};
 has lines         => default => sub {[]};
 has eos           => default => sub {0};
 has done          => default => sub {0};
 has anchor2node   => default => sub {{}};
 has level         => default => sub {0};
 has offset        => default => sub {[]};
 has preface       => default => sub {''};
 has content       => default => sub {''};
 has indent        => default => sub {0};
 has major_version => default => sub {0};
 has minor_version => default => sub {0};
 has inline        => default => sub {''};
 
 sub set_global_options {
     my $self = shift;
     $self->load_code($YAML::LoadCode || $YAML::UseCode)
       if defined $YAML::LoadCode or defined $YAML::UseCode;
 }
 
 sub load {
     die 'load() not implemented in this class.';
 }
 
 1;
### YAML/Marshall.pm ###
 use strict; use warnings;
 package YAML::Marshall;
 
 use YAML::Node ();
 
 sub import {
     my $class = shift;
     no strict 'refs';
     my $package = caller;
     unless (grep { $_ eq $class} @{$package . '::ISA'}) {
         push @{$package . '::ISA'}, $class;
     }
 
     my $tag = shift;
     if ( $tag ) {
         no warnings 'once';
         $YAML::TagClass->{$tag} = $package;
         ${$package . "::YamlTag"} = $tag;
     }
 }
 
 sub yaml_dump {
     my $self = shift;
     no strict 'refs';
     my $tag = ${ref($self) . "::YamlTag"} || 'perl/' . ref($self);
     $self->yaml_node($self, $tag);
 }
 
 sub yaml_load {
     my ($class, $node) = @_;
     if (my $ynode = $class->yaml_ynode($node)) {
         $node = $ynode->{NODE};
     }
     bless $node, $class;
 }
 
 sub yaml_node {
     shift;
     YAML::Node->new(@_);
 }
 
 sub yaml_ynode {
     shift;
     YAML::Node::ynode(@_);
 }
 
 1;
### YAML/Mo.pm ###
 package YAML::Mo; $VERSION = '0.88';
 no warnings;my$M=__PACKAGE__.'::';*{$M.Object::new}=sub{bless{@_[1..$#_]},$_[0]};*{$M.import}=sub{import warnings;$^H|=1538;my($P,%e,%o)=caller.'::';shift;eval"no Mo::$_",&{$M.$_.::e}($P,\%e,\%o,\@_)for@_;return if$e{M};%e=(extends,sub{eval"no $_[0]()";@{$P.ISA}=$_[0]},has,sub{my$n=shift;my$m=sub{$#_?$_[0]{$n}=$_[1]:$_[0]{$n}};$m=$o{$_}->($m,$n,@_)for sort keys%o;*{$P.$n}=$m},%e,);*{$P.$_}=$e{$_}for keys%e;@{$P.ISA}=$M.Object};*{$M.'builder::e'}=sub{my($P,$e,$o)=@_;$o->{builder}=sub{my($m,$n,%a)=@_;my$b=$a{builder}or return$m;sub{$#_?$m->(@_):!exists$_[0]{$n}?$_[0]{$n}=$_[0]->$b:$m->(@_)}}};*{$M.'default::e'}=sub{my($P,$e,$o)=@_;$o->{default}=sub{my($m,$n,%a)=@_;$a{default}or return$m;sub{$#_?$m->(@_):!exists$_[0]{$n}?$_[0]{$n}=$a{default}->(@_):$m->(@_)}}};my$i=\&import;*{$M.import}=sub{(@_==2 and not $_[1])?pop@_:@_==1?push@_,grep!/import/,@f:();goto&$i};@f=qw[builder default import];use strict;use warnings;
 
 our $DumperModule = 'Data::Dumper';
 
 my ($_new_error, $_info, $_scalar_info);
 
 no strict 'refs';
 *{$M.'Object::die'} = sub {
     my $self = shift;
     my $error = $self->$_new_error(@_);
     $error->type('Error');
     Carp::croak($error->format_message);
 };
 
 *{$M.'Object::warn'} = sub {
     my $self = shift;
     return unless $^W;
     my $error = $self->$_new_error(@_);
     $error->type('Warning');
     Carp::cluck($error->format_message);
 };
 
 *{$M.'Object::node_info'} = sub {
     my $self = shift;
     my $stringify = $_[1] || 0;
     my ($class, $type, $id) =
         ref($_[0])
         ? $stringify
           ? &$_info("$_[0]")
           : do {
               require overload;
               my @info = &$_info(overload::StrVal($_[0]));
               if (ref($_[0]) eq 'Regexp') {
                   @info[0, 1] = (undef, 'REGEXP');
               }
               @info;
           }
         : &$_scalar_info($_[0]);
     ($class, $type, $id) = &$_scalar_info("$_[0]")
         unless $id;
     return wantarray ? ($class, $type, $id) : $id;
 };
 
 $_info = sub {
     return (($_[0]) =~ qr{^(?:(.*)\=)?([^=]*)\(([^\(]*)\)$}o);
 };
 
 $_scalar_info = sub {
     my $id = 'undef';
     if (defined $_[0]) {
         \$_[0] =~ /\((\w+)\)$/o or CORE::die();
         $id = "$1-S";
     }
     return (undef, undef, $id);
 };
 
 $_new_error = sub {
     require Carp;
     my $self = shift;
     require YAML::Error;
 
     my $code = shift || 'unknown error';
     my $error = YAML::Error->new(code => $code);
     $error->line($self->line) if $self->can('line');
     $error->document($self->document) if $self->can('document');
     $error->arguments([@_]);
     return $error;
 };
 
 1;
### YAML/Node.pm ###
 use strict; use warnings;
 package YAML::Node;
 
 use YAML::Tag;
 require YAML::Mo;
 
 use Exporter;
 our @ISA     = qw(Exporter YAML::Mo::Object);
 our @EXPORT  = qw(ynode);
 
 sub ynode {
     my $self;
     if (ref($_[0]) eq 'HASH') {
         $self = tied(%{$_[0]});
     }
     elsif (ref($_[0]) eq 'ARRAY') {
         $self = tied(@{$_[0]});
     }
     elsif (ref(\$_[0]) eq 'GLOB') {
         $self = tied(*{$_[0]});
     }
     else {
         $self = tied($_[0]);
     }
     return (ref($self) =~ /^yaml_/) ? $self : undef;
 }
 
 sub new {
     my ($class, $node, $tag) = @_;
     my $self;
     $self->{NODE} = $node;
     my (undef, $type) = YAML::Mo::Object->node_info($node);
     $self->{KIND} = (not defined $type) ? 'scalar' :
                     ($type eq 'ARRAY') ? 'sequence' :
                     ($type eq 'HASH') ? 'mapping' :
                     $class->die("Can't create YAML::Node from '$type'");
     tag($self, ($tag || ''));
     if ($self->{KIND} eq 'scalar') {
         yaml_scalar->new($self, $_[1]);
         return \ $_[1];
     }
     my $package = "yaml_" . $self->{KIND};
     $package->new($self)
 }
 
 sub node { $_->{NODE} }
 sub kind { $_->{KIND} }
 sub tag {
     my ($self, $value) = @_;
     if (defined $value) {
                $self->{TAG} = YAML::Tag->new($value);
         return $self;
     }
     else {
        return $self->{TAG};
     }
 }
 sub keys {
     my ($self, $value) = @_;
     if (defined $value) {
                $self->{KEYS} = $value;
         return $self;
     }
     else {
        return $self->{KEYS};
     }
 }
 
 package yaml_scalar;
 
 @yaml_scalar::ISA = qw(YAML::Node);
 
 sub new {
     my ($class, $self) = @_;
     tie $_[2], $class, $self;
 }
 
 sub TIESCALAR {
     my ($class, $self) = @_;
     bless $self, $class;
     $self
 }
 
 sub FETCH {
     my ($self) = @_;
     $self->{NODE}
 }
 
 sub STORE {
     my ($self, $value) = @_;
     $self->{NODE} = $value
 }
 
 package yaml_sequence;
 
 @yaml_sequence::ISA = qw(YAML::Node);
 
 sub new {
     my ($class, $self) = @_;
     my $new;
     tie @$new, $class, $self;
     $new
 }
 
 sub TIEARRAY {
     my ($class, $self) = @_;
     bless $self, $class
 }
 
 sub FETCHSIZE {
     my ($self) = @_;
     scalar @{$self->{NODE}};
 }
 
 sub FETCH {
     my ($self, $index) = @_;
     $self->{NODE}[$index]
 }
 
 sub STORE {
     my ($self, $index, $value) = @_;
     $self->{NODE}[$index] = $value
 }
 
 sub undone {
     die "Not implemented yet"; 
 }
 
 *STORESIZE = *POP = *PUSH = *SHIFT = *UNSHIFT = *SPLICE = *DELETE = *EXISTS =
 *STORESIZE = *POP = *PUSH = *SHIFT = *UNSHIFT = *SPLICE = *DELETE = *EXISTS =
 *undone; 
 
 package yaml_mapping;
 
 @yaml_mapping::ISA = qw(YAML::Node);
 
 sub new {
     my ($class, $self) = @_;
     @{$self->{KEYS}} = sort keys %{$self->{NODE}};
     my $new;
     tie %$new, $class, $self;
     $new
 }
 
 sub TIEHASH {
     my ($class, $self) = @_;
     bless $self, $class
 }
 
 sub FETCH {
     my ($self, $key) = @_;
     if (exists $self->{NODE}{$key}) {
         return (grep {$_ eq $key} @{$self->{KEYS}})
                ? $self->{NODE}{$key} : undef;
     }
     return $self->{HASH}{$key};
 }
 
 sub STORE {
     my ($self, $key, $value) = @_;
     if (exists $self->{NODE}{$key}) {
         $self->{NODE}{$key} = $value;
     }
     elsif (exists $self->{HASH}{$key}) {
         $self->{HASH}{$key} = $value;
     }
     else {
         if (not grep {$_ eq $key} @{$self->{KEYS}}) {
             push(@{$self->{KEYS}}, $key);
         }
         $self->{HASH}{$key} = $value;
     }
     $value
 }
 
 sub DELETE {
     my ($self, $key) = @_;
     my $return;
     if (exists $self->{NODE}{$key}) {
         $return = $self->{NODE}{$key};
     }
     elsif (exists $self->{HASH}{$key}) {
         $return = delete $self->{NODE}{$key};
     }
     for (my $i = 0; $i < @{$self->{KEYS}}; $i++) {
         if ($self->{KEYS}[$i] eq $key) {
             splice(@{$self->{KEYS}}, $i, 1);
         }
     }
     return $return;
 }
 
 sub CLEAR {
     my ($self) = @_;
     @{$self->{KEYS}} = ();
     %{$self->{HASH}} = ();
 }
 
 sub FIRSTKEY {
     my ($self) = @_;
     $self->{ITER} = 0;
     $self->{KEYS}[0]
 }
 
 sub NEXTKEY {
     my ($self) = @_;
     $self->{KEYS}[++$self->{ITER}]
 }
 
 sub EXISTS {
     my ($self, $key) = @_;
     exists $self->{NODE}{$key}
 }
 
 1;
### YAML/Tag.pm ###
 use strict; use warnings;
 package YAML::Tag;
 
 use overload '""' => sub { ${$_[0]} };
 
 sub new {
     my ($class, $self) = @_;
     bless \$self, $class
 }
 
 sub short {
     ${$_[0]}
 }
 
 sub canonical {
     ${$_[0]}
 }
 
 1;
### YAML/Types.pm ###
 package YAML::Types;
 
 use YAML::Mo;
 use YAML::Node;
 
 package YAML::Type::blessed;
 
 use YAML::Mo; 
 
 sub yaml_dump {
     my $self = shift;
     my ($value) = @_;
     my ($class, $type) = YAML::Mo::Object->node_info($value);
     no strict 'refs';
     my $kind = lc($type) . ':';
     my $tag = ${$class . '::ClassTag'} ||
               "!perl/$kind$class";
     if ($type eq 'REF') {
         YAML::Node->new(
             {(&YAML::VALUE, ${$_[0]})}, $tag
         );
     }
     elsif ($type eq 'SCALAR') {
         $_[1] = $$value;
         YAML::Node->new($_[1], $tag);
     }
     elsif ($type eq 'GLOB') {
         return YAML::Type::glob->yaml_dump($value, $tag);
     } else {
         YAML::Node->new($value, $tag);
     }
 }
 
 package YAML::Type::undef;
 
 sub yaml_dump {
     my $self = shift;
 }
 
 sub yaml_load {
     my $self = shift;
 }
 
 package YAML::Type::glob;
 
 sub yaml_dump {
     my $self = shift;
     my $tag = pop @_ if 2==@_;
 
     $tag = '!perl/glob:' unless defined $tag;
     my $ynode = YAML::Node->new({}, $tag);
     for my $type (qw(PACKAGE NAME SCALAR ARRAY HASH CODE IO)) {
         my $value = *{$_[0]}{$type};
         $value = $$value if $type eq 'SCALAR';
         if (defined $value) {
             if ($type eq 'IO') {
                 my @stats = qw(device inode mode links uid gid rdev size
                                atime mtime ctime blksize blocks);
                 undef $value;
                 $value->{stat} = YAML::Node->new({});
                 if ($value->{fileno} = fileno(*{$_[0]})) {
                     local $^W;
                     map {$value->{stat}{shift @stats} = $_} stat(*{$_[0]});
                     $value->{tell} = tell(*{$_[0]});
                 }
             }
             $ynode->{$type} = $value;
         }
     }
     return $ynode;
 }
 
 sub yaml_load {
     my $self = shift;
     my ($node, $class, $loader) = @_;
     my ($name, $package);
     if (defined $node->{NAME}) {
         $name = $node->{NAME};
         delete $node->{NAME};
     }
     else {
         $loader->warn('YAML_LOAD_WARN_GLOB_NAME');
         return undef;
     }
     if (defined $node->{PACKAGE}) {
         $package = $node->{PACKAGE};
         delete $node->{PACKAGE};
     }
     else {
         $package = 'main';
     }
     no strict 'refs';
     if (exists $node->{SCALAR}) {
         *{"${package}::$name"} = \$node->{SCALAR};
         delete $node->{SCALAR};
     }
     for my $elem (qw(ARRAY HASH CODE IO)) {
         if (exists $node->{$elem}) {
             if ($elem eq 'IO') {
                 $loader->warn('YAML_LOAD_WARN_GLOB_IO');
                 delete $node->{IO};
                 next;
             }
             *{"${package}::$name"} = $node->{$elem};
             delete $node->{$elem};
         }
     }
     for my $elem (sort keys %$node) {
         $loader->warn('YAML_LOAD_WARN_BAD_GLOB_ELEM', $elem);
     }
     return *{"${package}::$name"};
 }
 
 package YAML::Type::code;
 
 my $dummy_warned = 0;
 my $default = '{ "DUMMY" }';
 
 sub yaml_dump {
     my $self = shift;
     my $code;
     my ($dumpflag, $value) = @_;
     my ($class, $type) = YAML::Mo::Object->node_info($value);
     my $tag = "!perl/code";
     $tag .= ":$class" if defined $class;
     if (not $dumpflag) {
         $code = $default;
     }
     else {
         bless $value, "CODE" if $class;
         eval { use B::Deparse };
         return if $@;
         my $deparse = B::Deparse->new();
         eval {
             local $^W = 0;
             $code = $deparse->coderef2text($value);
         };
         if ($@) {
             warn YAML::YAML_DUMP_WARN_DEPARSE_FAILED() if $^W;
             $code = $default;
         }
         bless $value, $class if $class;
         chomp $code;
         $code .= "\n";
     }
     $_[2] = $code;
     YAML::Node->new($_[2], $tag);
 }
 
 sub yaml_load {
     my $self = shift;
     my ($node, $class, $loader) = @_;
     if ($loader->load_code) {
         my $code = eval "package main; sub $node";
         if ($@) {
             $loader->warn('YAML_LOAD_WARN_PARSE_CODE', $@);
             return sub {};
         }
         else {
             CORE::bless $code, $class if $class;
             return $code;
         }
     }
     else {
         return CORE::bless sub {}, $class if $class;
         return sub {};
     }
 }
 
 package YAML::Type::ref;
 
 sub yaml_dump {
     my $self = shift;
     YAML::Node->new({(&YAML::VALUE, ${$_[0]})}, '!perl/ref')
 }
 
 sub yaml_load {
     my $self = shift;
     my ($node, $class, $loader) = @_;
     $loader->die('YAML_LOAD_ERR_NO_DEFAULT_VALUE', 'ptr')
       unless exists $node->{&YAML::VALUE};
     return \$node->{&YAML::VALUE};
 }
 
 package YAML::Type::regexp;
 
 sub yaml_dump {
     die "YAML::Type::regexp::yaml_dump not currently implemented";
 }
 
 use constant _QR_TYPES => {
     '' => sub { qr{$_[0]} },
     x => sub { qr{$_[0]}x },
     i => sub { qr{$_[0]}i },
     s => sub { qr{$_[0]}s },
     m => sub { qr{$_[0]}m },
     ix => sub { qr{$_[0]}ix },
     sx => sub { qr{$_[0]}sx },
     mx => sub { qr{$_[0]}mx },
     si => sub { qr{$_[0]}si },
     mi => sub { qr{$_[0]}mi },
     ms => sub { qr{$_[0]}sm },
     six => sub { qr{$_[0]}six },
     mix => sub { qr{$_[0]}mix },
     msx => sub { qr{$_[0]}msx },
     msi => sub { qr{$_[0]}msi },
     msix => sub { qr{$_[0]}msix },
 };
 
 sub yaml_load {
     my $self = shift;
     my ($node, $class) = @_;
     return qr{$node} unless $node =~ /^\(\?([\^\-xism]*):(.*)\)\z/s;
     my ($flags, $re) = ($1, $2);
     $flags =~ s/-.*//;
     $flags =~ s/^\^//;
     my $sub = _QR_TYPES->{$flags} || sub { qr{$_[0]} };
     my $qr = &$sub($re);
     bless $qr, $class if length $class;
     return $qr;
 }
 
 1;
### experimental.pm ###
 package experimental;
 $experimental::VERSION = '0.013';
 use strict;
 use warnings;
 use version ();
 
 use feature ();
 use Carp qw/croak carp/;
 
 my %warnings = map { $_ => 1 } grep { /^experimental::/ } keys %warnings::Offsets;
 my %features = map { $_ => 1 } $] > 5.015006 ? keys %feature::feature : do {
 	my @features;
 	if ($] >= 5.010) {
 		push @features, qw/switch say state/;
 		push @features, 'unicode_strings' if $] > 5.011002;
 	}
 	@features;
 };
 
 my %min_version = (
 	array_base      => '5',
 	autoderef       => '5.14.0',
 	current_sub     => '5.16.0',
 	evalbytes       => '5.16.0',
 	fc              => '5.16.0',
 	lexical_topic   => '5.10.0',
 	lexical_subs    => '5.18.0',
 	postderef       => '5.20.0',
 	postderef_qq    => '5.20.0',
 	refaliasing     => '5.21.5',
 	regex_sets      => '5.18.0',
 	say             => '5.10.0',
 	smartmatch      => '5.10.0',
 	signatures      => '5.20.0',
 	state           => '5.10.0',
 	switch          => '5.10.0',
 	unicode_eval    => '5.16.0',
 	unicode_strings => '5.12.0',
 );
 $_ = version->new($_) for values %min_version;
 
 my %additional = (
 	postderef  => ['postderef_qq'],
 	switch     => ['smartmatch'],
 );
 
 sub _enable {
 	my $pragma = shift;
 	if ($warnings{"experimental::$pragma"}) {
 		warnings->unimport("experimental::$pragma");
 		feature->import($pragma) if exists $features{$pragma};
 		_enable(@{ $additional{$pragma} }) if $additional{$pragma};
 	}
 	elsif ($features{$pragma}) {
 		feature->import($pragma);
 		_enable(@{ $additional{$pragma} }) if $additional{$pragma};
 	}
 	elsif (not exists $min_version{$pragma}) {
 		croak "Can't enable unknown feature $pragma";
 	}
 	elsif ($min_version{$pragma} > $]) {
 		my $stable = $min_version{$pragma};
 		if ($stable->{version}[1] % 2) {
 			$stable = version->new(
 				"5.".($stable->{version}[1]+1).'.0'
 			);
 		}
 		croak "Need perl $stable or later for feature $pragma";
 	}
 }
 
 sub import {
 	my ($self, @pragmas) = @_;
 
 	for my $pragma (@pragmas) {
 		_enable($pragma);
 	}
 	return;
 }
 
 sub _disable {
 	my $pragma = shift;
 	if ($warnings{"experimental::$pragma"}) {
 		warnings->import("experimental::$pragma");
 		feature->unimport($pragma) if exists $features{$pragma};
 		_disable(@{ $additional{$pragma} }) if $additional{$pragma};
 	}
 	elsif ($features{$pragma}) {
 		feature->unimport($pragma);
 		_disable(@{ $additional{$pragma} }) if $additional{$pragma};
 	}
 	elsif (not exists $min_version{$pragma}) {
 		carp "Can't disable unknown feature $pragma, ignoring";
 	}
 }
 
 sub unimport {
 	my ($self, @pragmas) = @_;
 
 	for my $pragma (@pragmas) {
 		_disable($pragma);
 	}
 	return;
 }
 
 1;
 
 
 __END__
 
### namespace/clean.pm ###
 package namespace::clean;
 
 use warnings;
 use strict;
 
 our $VERSION = '0.26';
 $VERSION = eval $VERSION if $VERSION =~ /_/; 
 
 our $STORAGE_VAR = '__NAMESPACE_CLEAN_STORAGE';
 
 use B::Hooks::EndOfScope 'on_scope_end';
 
 BEGIN {
   my $provider;
 
   if ( $] < 5.008007 ) {
     require Package::Stash::PP;
     $provider = 'Package::Stash::PP';
   }
   else {
     require Package::Stash;
     $provider = 'Package::Stash';
   }
   eval <<"EOS" or die $@;
 
 sub stash_for (\$) {
   $provider->new(\$_[0]);
 }
 
 1;
 
 EOS
 }
 
 use namespace::clean::_Util qw( DEBUGGER_NEEDS_CV_RENAME DEBUGGER_NEEDS_CV_PIVOT );
 
 
 my $RemoveSubs = sub {
     my $cleanee = shift;
     my $store   = shift;
     my $cleanee_stash = stash_for($cleanee);
     my $deleted_stash;
 
   SYMBOL:
     for my $f (@_) {
 
         next SYMBOL if $store->{exclude}{ $f };
 
         my $sub = $cleanee_stash->get_symbol("&$f")
           or next SYMBOL;
 
         my $need_debugger_fixup =
           ( DEBUGGER_NEEDS_CV_RENAME or DEBUGGER_NEEDS_CV_PIVOT )
             &&
           $^P
             &&
           ref(my $globref = \$cleanee_stash->namespace->{$f}) eq 'GLOB'
             &&
          ( $deleted_stash ||= stash_for("namespace::clean::deleted::$cleanee") )
         ;
 
         if ( DEBUGGER_NEEDS_CV_RENAME and $need_debugger_fixup ) {
           namespace::clean::_Util::get_subname( $sub ) eq  ( $cleanee_stash->name . "::$f" )
             and
           $deleted_stash->add_symbol(
             "&$f",
             namespace::clean::_Util::set_subname( $deleted_stash->name . "::$f", $sub ),
           );
         }
         elsif ( DEBUGGER_NEEDS_CV_PIVOT and $need_debugger_fixup ) {
           $deleted_stash->add_symbol("&$f", $sub);
         }
 
         my @symbols = map {
             my $name = $_ . $f;
             my $def = $cleanee_stash->get_symbol($name);
             defined($def) ? [$name, $def] : ()
         } '$', '@', '%', '';
 
         $cleanee_stash->remove_glob($f);
 
         DEBUGGER_NEEDS_CV_PIVOT
           and
         $need_debugger_fixup
           and
         *$globref = $deleted_stash->namespace->{$f};
 
         $cleanee_stash->add_symbol(@$_) for @symbols;
     }
 };
 
 sub clean_subroutines {
     my ($nc, $cleanee, @subs) = @_;
     $RemoveSubs->($cleanee, {}, @subs);
 }
 
 sub import {
     my ($pragma, @args) = @_;
 
     my (%args, $is_explicit);
 
   ARG:
     while (@args) {
 
         if ($args[0] =~ /^\-/) {
             my $key = shift @args;
             my $value = shift @args;
             $args{ $key } = $value;
         }
         else {
             $is_explicit++;
             last ARG;
         }
     }
 
     my $cleanee = exists $args{ -cleanee } ? $args{ -cleanee } : scalar caller;
     if ($is_explicit) {
         on_scope_end {
             $RemoveSubs->($cleanee, {}, @args);
         };
     }
     else {
 
         my $functions = $pragma->get_functions($cleanee);
         my $store     = $pragma->get_class_store($cleanee);
         my $stash     = stash_for($cleanee);
 
         my %except = map {( $_ => 1 )} (
             $args{ -except }
             ? ( ref $args{ -except } eq 'ARRAY' ? @{ $args{ -except } } : $args{ -except } )
             : ()
         );
 
         for my $f (keys %$functions) {
             next if     $except{ $f };
             next unless $stash->has_symbol("&$f");
             $store->{remove}{ $f } = 1;
         }
 
         unless ($store->{handler_is_installed}) {
             on_scope_end {
                 $RemoveSubs->($cleanee, $store, keys %{ $store->{remove} });
             };
             $store->{handler_is_installed} = 1;
         }
 
         return 1;
     }
 }
 
 sub unimport {
     my ($pragma, %args) = @_;
 
     my $cleanee   = exists $args{ -cleanee } ? $args{ -cleanee } : scalar caller;
     my $functions = $pragma->get_functions($cleanee);
     my $store     = $pragma->get_class_store($cleanee);
 
     for my $f (keys %$functions) {
         next if $store->{remove}{ $f }
              or $store->{exclude}{ $f };
         $store->{exclude}{ $f } = 1;
     }
 
     return 1;
 }
 
 sub get_class_store {
     my ($pragma, $class) = @_;
     my $stash = stash_for($class);
     my $var = "%$STORAGE_VAR";
     $stash->add_symbol($var, {})
         unless $stash->has_symbol($var);
     return $stash->get_symbol($var);
 }
 
 sub get_functions {
     my ($pragma, $class) = @_;
 
     my $stash = stash_for($class);
     return {
         map { $_ => $stash->get_symbol("&$_") }
             $stash->list_all_symbols('CODE')
     };
 }
 
 'Danger! Laws of Thermodynamics may not apply.'
 
 __END__
 
### oo.pm ###
 package oo;
 
 use Moo::_strictures;
 use Moo::_Utils;
 
 sub moo {
   print <<'EOMOO';
  ______
 < Moo! >
  ------
         \   ^__^
          \  (oo)\_______
             (__)\       )\/\
                 ||----w |
                 ||     ||
 EOMOO
   exit 0;
 }
 
 BEGIN {
     my $package;
     sub import {
         moo() if $0 eq '-';
         $package = $_[1] || 'Class';
         if ($package =~ /^\+/) {
             $package =~ s/^\+//;
             _load_module($package);
         }
     }
     use Filter::Simple sub { s/^/package $package;\nuse Moo;\n/; }
 }
 
 1;
 __END__
 
