#!/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 = '2017-02-03'; # DATE
our $DIST = 'File-RsyBak'; # DIST
our $VERSION = '0.31'; # 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.31 of rsybak (from Perl distribution File-RsyBak), released on 2017-02-03.

=head1 SYNOPSIS

Usage:

 % rsybak [options] <source> <target>

=head1 OPTIONS

C<*> marks required options.

=head2 Main 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<--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<i@>

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.

=back

=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<--help>, B<-h>, B<-?>

Display help message and exit.

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

Display program's version and exit.

=back

=head1 COMPLETION

The script comes with a companion shell completer script (L<rsybak>)
for this script.

=head2 bash

To activate bash completion for this script, put:

 complete -C rsybak rsybak

in your bash startup (e.g. F<~/.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 L<shcompgen>) at installation time,
so you can immediately have tab completion.

=head2 tcsh

To activate tcsh completion for this script, put:

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

in your tcsh startup (e.g. F<~/.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 L<shcompgen> (see above).

=head2 other shells

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

=head1 CONFIGURATION FILE

This script can read configuration files. Configuration files are in the format of L<IOD>, which is basically INI with some extra features.

By default, these names are searched for configuration filenames (can be changed using C<--config-path>): F<~/.config/rsybak.conf>, F<~/rsybak.conf>, or F</etc/rsybak.conf>.

All found files will be read and merged.

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

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

You can also put configuration for multiple programs inside a single file, and use filter C<program=NAME> in section names, e.g. C<[program=NAME ...]> or C<[SOMESECTION program=NAME]>. The section will then only be used when the reading program matches.

Finally, you can filter a section by environment variable using the filter C<env=CONDITION> in section names. For example if you only want a section to be read if a certain environment variable is true: C<[env=SOMEVAR ...]> or C<[SOMESECTION env=SOMEVAR ...]>. If you only want a section to be read when the value of an environment variable has value equals something: C<[env=HOSTNAME=blink ...]> or C<[SOMESECTION env=HOSTNAME=blink ...]>. If you only want a section to be read when the value of an environment variable does not equal something: C<[env=HOSTNAME!=blink ...]> or C<[SOMESECTION env=HOSTNAME!=blink ...]>. If you only want a section to be read when an environment variable contains something: C<[env=HOSTNAME*=server ...]> or C<[SOMESECTION env=HOSTNAME*=server ...]>. Note that currently due to simplistic parsing, there must not be any whitespace in the value being compared because it marks the beginning of a new section filter or section name.

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 ENVIRONMENT

=head2 RSYBAK_OPT => str

Specify additional command-line options.

=head1 FILES

F<~/.config/rsybak.conf>

F<~/rsybak.conf>

F</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) 2017 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.

=cut

__DATA__
Data::Section::Seekable v1
B/Hooks/EndOfScope.pm,30,445,0;0
B/Hooks/EndOfScope/PP.pm,508,1282,1;26
B/Hooks/EndOfScope/XS.pm,1823,631,2;74
Border/Style.pm,2478,98,3;110
Border/Style/Role.pm,2605,2788,4;119
Capture/Tiny.pm,5417,10382,5;230
Class/Inspector.pm,15826,5934,6;567
Class/Inspector/Functions.pm,21797,708,7;864
Class/Method/Modifiers.pm,22539,4713,8;911
Clone/PP.pm,27272,1884,9;1098
Color/ANSI/Util.pm,29183,10958,10;1169
Color/RGB/Util.pm,40167,4182,11;1480
Color/Theme.pm,44372,97,12;1635
Color/Theme/Role.pm,44497,3009,13;1644
Color/Theme/Role/ANSI.pm,47539,2464,14;1764
Color/Theme/Util.pm,50031,1329,15;1850
Complete/Bash.pm,51385,17459,16;1901
Complete/Common.pm,68871,945,17;2426
Complete/Env.pm,69840,2999,18;2465
Complete/File.pm,72864,8532,19;2590
Complete/Fish.pm,81421,2069,20;2863
Complete/Getopt/Long.pm,83522,18507,21;2953
Complete/Path.pm,102054,7990,22;3507
Complete/Tcsh.pm,110069,2757,23;3768
Complete/Util.pm,112851,20695,24;3873
Complete/Zsh.pm,133570,1345,25;4583
Config/IOD/Base.pm,134942,13009,26;4645
Config/IOD/Expr.pm,147978,1287,27;5137
Config/IOD/Reader.pm,149294,6377,28;5222
Data/Check/Structure.pm,155703,3555,29;5429
Data/Clean.pm,159280,7970,30;5594
Data/Clean/FromJSON.pm,167281,536,31;5866
Data/Clean/JSON.pm,167844,1140,32;5898
Data/Dmp.pm,169004,4396,33;5950
Data/Dump.pm,173421,12066,34;6134
Data/Dump/FilterContext.pm,185522,1740,35;6667
Data/Dump/Filtered.pm,187292,812,36;6761
Data/Dump/OneLine.pm,188133,325,37;6794
Data/Dump/Partial.pm,188487,5169,38;6815
Data/Dump/Trace.pm,193683,6339,39;6967
Data/Format/Pretty.pm,200052,921,40;7233
Data/Format/Pretty/CompactJSON.pm,201015,690,41;7283
Data/Format/Pretty/Console.pm,201743,12223,42;7319
Data/Format/Pretty/HTML.pm,214001,2897,43;7755
Data/Format/Pretty/JSON.pm,216933,1107,44;7877
Data/Format/Pretty/SimpleText.pm,218081,480,45;7924
Data/Format/Pretty/Text.pm,218596,474,46;7951
Data/ModeMerge.pm,219096,10593,47;7978
Data/ModeMerge/Config.pm,229722,2140,48;8296
Data/ModeMerge/Mode/ADD.pm,231897,1373,49;8367
Data/ModeMerge/Mode/Base.pm,233306,16705,50;8436
Data/ModeMerge/Mode/CONCAT.pm,250049,442,51;8966
Data/ModeMerge/Mode/DELETE.pm,250529,1218,52;8994
Data/ModeMerge/Mode/KEEP.pm,251783,1174,53;9069
Data/ModeMerge/Mode/NORMAL.pm,252995,1501,54;9137
Data/ModeMerge/Mode/SUBTRACT.pm,254536,2064,55;9230
Data/Sah.pm,256620,2541,56;9322
Data/Sah/Coerce.pm,259188,2739,57;9435
Data/Sah/Coerce/js/bool/float.pm,261968,560,58;9545
Data/Sah/Coerce/js/bool/str.pm,262567,717,59;9585
Data/Sah/Coerce/js/date/float_epoch.pm,263331,590,60;9628
Data/Sah/Coerce/js/date/obj_Date.pm,263965,597,61;9668
Data/Sah/Coerce/js/date/str.pm,264601,625,62;9707
Data/Sah/Coerce/js/duration/float_secs.pm,265276,741,63;9746
Data/Sah/Coerce/js/duration/str_iso8601.pm,266068,967,64;9788
Data/Sah/Coerce/perl/bool/str.pm,267076,561,65;9831
Data/Sah/Coerce/perl/date/float_epoch.pm,267686,1162,66;9869
Data/Sah/Coerce/perl/date/obj_DateTime.pm,268898,1094,67;9922
Data/Sah/Coerce/perl/date/obj_TimeMoment.pm,270044,1232,68;9974
Data/Sah/Coerce/perl/date/str_iso8601.pm,271325,1494,69;10026
Data/Sah/Coerce/perl/duration/float_secs.pm,272871,970,70;10081
Data/Sah/Coerce/perl/duration/obj_DateTimeDuration.pm,273903,1137,71;10129
Data/Sah/Coerce/perl/duration/str_human.pm,275091,1719,72;10178
Data/Sah/Coerce/perl/duration/str_iso8601.pm,276863,1447,73;10228
Data/Sah/CoerceCommon.pm,278343,8108,74;10277
Data/Sah/CoerceJS.pm,286480,3115,75;10545
Data/Sah/Compiler.pm,289624,20179,76;10664
Data/Sah/Compiler/Prog.pm,309837,23982,77;11360
Data/Sah/Compiler/Prog/TH.pm,333856,3108,78;12141
Data/Sah/Compiler/Prog/TH/all.pm,337005,534,79;12268
Data/Sah/Compiler/Prog/TH/any.pm,337580,534,80;12300
Data/Sah/Compiler/TH.pm,338146,1247,81;12332
Data/Sah/Compiler/TextResultRole.pm,339437,1190,82;12398
Data/Sah/Compiler/human.pm,340662,12247,83;12460
Data/Sah/Compiler/human/TH.pm,352947,1082,84;12904
Data/Sah/Compiler/human/TH/Comparable.pm,354078,688,85;12970
Data/Sah/Compiler/human/TH/HasElems.pm,354813,1964,86;13002
Data/Sah/Compiler/human/TH/Sortable.pm,356824,1543,87;13074
Data/Sah/Compiler/human/TH/all.pm,358409,1852,88;13141
Data/Sah/Compiler/human/TH/any.pm,360303,1801,89;13221
Data/Sah/Compiler/human/TH/array.pm,362148,2853,90;13300
Data/Sah/Compiler/human/TH/bool.pm,365044,1152,91;13411
Data/Sah/Compiler/human/TH/buf.pm,366238,472,92;13469
Data/Sah/Compiler/human/TH/cistr.pm,366754,266,93;13499
Data/Sah/Compiler/human/TH/code.pm,367063,470,94;13517
Data/Sah/Compiler/human/TH/date.pm,367576,564,95;13546
Data/Sah/Compiler/human/TH/duration.pm,368187,584,96;13576
Data/Sah/Compiler/human/TH/float.pm,368815,2136,97;13606
Data/Sah/Compiler/human/TH/hash.pm,370994,8935,98;13703
Data/Sah/Compiler/human/TH/int.pm,379971,1741,99;14044
Data/Sah/Compiler/human/TH/num.pm,381754,568,100;14123
Data/Sah/Compiler/human/TH/obj.pm,382364,901,101;14153
Data/Sah/Compiler/human/TH/re.pm,383306,516,102;14204
Data/Sah/Compiler/human/TH/str.pm,383864,2306,103;14235
Data/Sah/Compiler/human/TH/undef.pm,386214,528,104;14340
Data/Sah/Compiler/perl.pm,386776,9722,105;14371
Data/Sah/Compiler/perl/TH.pm,396535,1300,106;14772
Data/Sah/Compiler/perl/TH/all.pm,397876,316,107;14820
Data/Sah/Compiler/perl/TH/any.pm,398233,316,108;14842
Data/Sah/Compiler/perl/TH/array.pm,398592,4412,109;14864
Data/Sah/Compiler/perl/TH/bool.pm,403046,2360,110;14998
Data/Sah/Compiler/perl/TH/buf.pm,405447,292,111;15082
Data/Sah/Compiler/perl/TH/cistr.pm,405782,3621,112;15101
Data/Sah/Compiler/perl/TH/code.pm,409445,456,113;15234
Data/Sah/Compiler/perl/TH/date.pm,409943,5699,114;15261
Data/Sah/Compiler/perl/TH/duration.pm,415688,5788,115;15417
Data/Sah/Compiler/perl/TH/float.pm,421519,6295,116;15583
Data/Sah/Compiler/perl/TH/hash.pm,427856,15326,117;15767
Data/Sah/Compiler/perl/TH/int.pm,443223,1065,118;16236
Data/Sah/Compiler/perl/TH/num.pm,444329,2067,119;16287
Data/Sah/Compiler/perl/TH/obj.pm,446437,882,120;16363
Data/Sah/Compiler/perl/TH/re.pm,447359,523,121;16409
Data/Sah/Compiler/perl/TH/str.pm,447923,5218,122;16438
Data/Sah/Compiler/perl/TH/undef.pm,453184,453,123;16609
Data/Sah/Human.pm,453663,667,124;16636
Data/Sah/Lang.pm,454355,261,125;16671
Data/Sah/Lang/fr_FR.pm,454647,1563,126;16692
Data/Sah/Lang/id_ID.pm,456241,8191,127;16798
Data/Sah/Lang/zh_CN.pm,464463,1463,128;17194
Data/Sah/Normalize.pm,465956,6073,129;17301
Data/Sah/Resolve.pm,472057,3458,130;17482
Data/Sah/Type/BaseType.pm,475549,2720,131;17585
Data/Sah/Type/Comparable.pm,478305,735,132;17718
Data/Sah/Type/HasElems.pm,479074,3599,133;17751
Data/Sah/Type/Sortable.pm,482707,1980,134;17895
Data/Sah/Type/all.pm,484716,463,135;17978
Data/Sah/Type/any.pm,485208,463,136;18001
Data/Sah/Type/array.pm,485702,756,137;18024
Data/Sah/Type/bool.pm,486488,437,138;18057
Data/Sah/Type/buf.pm,486954,179,139;18081
Data/Sah/Type/cistr.pm,487164,181,140;18095
Data/Sah/Type/code.pm,487375,185,141;18109
Data/Sah/Type/date.pm,487590,300,142;18123
Data/Sah/Type/duration.pm,487924,304,143;18141
Data/Sah/Type/float.pm,488259,886,144;18159
Data/Sah/Type/hash.pm,489175,4580,145;18206
Data/Sah/Type/int.pm,493784,648,146;18394
Data/Sah/Type/num.pm,494461,256,147;18425
Data/Sah/Type/obj.pm,494746,509,148;18441
Data/Sah/Type/re.pm,495283,224,149;18469
Data/Sah/Type/str.pm,495536,775,150;18484
Data/Sah/Type/undef.pm,496342,167,151;18523
Data/Sah/Util/Func.pm,496539,329,152;18535
Data/Sah/Util/Role.pm,496898,3345,153;18558
Data/Sah/Util/Type.pm,500273,3406,154;18673
Data/Sah/Util/Type/Date.pm,503714,5074,155;18802
Data/Sah/Util/TypeX.pm,508819,337,156;18948
Devel/GlobalDestruction.pm,509191,665,157;18973
Dist/CheckConflicts.pm,509887,5023,158;19007
Encode/Locale.pm,514935,4317,159;19203
File/Flock/Retry.pm,519280,1846,160;19368
File/HomeDir.pm,521150,6297,161;19469
File/HomeDir/Darwin.pm,527478,2054,162;19743
File/HomeDir/Darwin/Carbon.pm,529570,2564,163;19861
File/HomeDir/Darwin/Cocoa.pm,532171,2079,164;20013
File/HomeDir/Driver.pm,534281,231,165;20131
File/HomeDir/FreeDesktop.pm,534548,1824,166;20149
File/HomeDir/MacOS9.pm,536403,1282,167;20223
File/HomeDir/Test.pm,537714,1608,168;20305
File/HomeDir/Unix.pm,539351,1491,169;20393
File/HomeDir/Windows.pm,540874,2456,170;20512
File/Listing.pm,543354,7072,171;20654
File/RsyBak.pm,550449,11709,172;21003
File/RsyBak/Packed.pm,562188,107,173;21363
File/ShareDir.pm,562320,6309,174;21373
File/ShareDir/Tarball.pm,568662,1502,175;21678
File/Slurp/Tiny.pm,570191,2063,176;21756
File/Slurper.pm,572278,2550,177;21829
File/Which.pm,574850,2267,178;21928
File/Write/Rotate.pm,577146,11033,179;22043
File/chdir.pm,588201,3979,180;22459
Function/Fallback/CoreOrPP.pm,592218,1761,181;22647
Getopt/Long/Negate/EN.pm,594012,1797,182;22738
Getopt/Long/Util.pm,595837,9068,183;22790
HTML/Entities.pm,604930,8447,184;23121
HTML/Filter.pm,613400,500,185;23461
HTML/HeadParser.pm,613927,3428,186;23484
HTML/LinkExtor.pm,617381,1467,187;23635
HTML/Parser.pm,618871,2600,188;23710
HTML/PullParser.pm,621498,2323,189;23832
HTML/Tagset.pm,623844,4076,190;23940
HTML/TokeParser.pm,627947,3234,191;24135
HTTP/Config.pm,631204,6230,192;24290
HTTP/Cookies.pm,637458,12995,193;24527
HTTP/Cookies/Microsoft.pm,650487,4420,194;25090
HTTP/Cookies/Netscape.pm,654940,1745,195;25306
HTTP/Daemon.pm,656708,13398,196;25376
HTTP/Date.pm,670127,5770,197;25977
HTTP/Headers.pm,675921,10708,198;26224
HTTP/Headers/Auth.pm,686658,1769,199;26671
HTTP/Headers/ETag.pm,688456,1831,200;26764
HTTP/Headers/Util.pm,690316,1623,201;26850
HTTP/Message.pm,691963,18232,202;26942
HTTP/Negotiate.pm,710221,5965,203;27678
HTTP/Request.pm,716210,2603,204;27922
HTTP/Request/Common.pm,718844,7085,205;28056
HTTP/Response.pm,725954,6948,206;28352
HTTP/Status.pm,732925,3451,207;28675
HTTP/Tiny.pm,736397,36936,208;28788
HTTP/Tiny/UNIX.pm,773359,2136,209;30018
IO/HTML.pm,775514,5421,210;30116
IO/Pty.pm,780953,3553,211;30340
IO/Socket/UNIX/Util.pm,784537,1849,212;30487
IO/Tty.pm,786404,2398,213;30568
IPC/Run.pm,788821,58501,214;30676
IPC/Run/Debug.pm,847347,5820,215;32780
IPC/Run/IO.pm,853189,9028,216;33021
IPC/Run/Timer.pm,862242,5982,217;33423
IPC/Run/Win32Helper.pm,868255,8528,218;33726
IPC/Run/Win32IO.pm,876810,10764,219;34016
IPC/Run/Win32Pump.pm,887603,2368,220;34463
IPC/System/Options.pm,890001,10076,221;34561
JSON.pm,900093,71912,222;34908
JSON/Color.pm,972027,5236,223;37207
JSON/MaybeXS.pm,977287,2412,224;37417
JSON/PP.pm,979718,41741,225;37517
JSON/PP/Boolean.pm,1021486,43,226;39071
LWP.pm,1021544,127,227;39078
LWP/Authen/Basic.pm,1021699,2007,228;39090
LWP/Authen/Digest.pm,1023735,1965,229;39153
LWP/Authen/Ntlm.pm,1025727,2119,230;39227
LWP/ConnCache.pm,1027871,3375,231;39314
LWP/Debug.pm,1031267,1159,232;39484
LWP/DebugFile.pm,1032451,33,233;39552
LWP/MediaTypes.pm,1032510,3425,234;39556
LWP/MemberMixin.pm,1035962,195,235;39737
LWP/Protocol.pm,1036181,4320,236;39752
LWP/Protocol/cpan.pm,1040530,1303,237;39938
LWP/Protocol/data.pm,1041862,1183,238;40006
LWP/Protocol/file.pm,1043074,3475,239;40055
LWP/Protocol/ftp.pm,1046577,15283,240;40186
LWP/Protocol/gopher.pm,1061891,4821,241;40687
LWP/Protocol/http.pm,1066741,12139,242;40880
LWP/Protocol/http/SocketUnixAlt.pm,1078923,6636,243;41342
LWP/Protocol/loopback.pm,1085592,627,244;41611
LWP/Protocol/mailto.pm,1086250,4304,245;41637
LWP/Protocol/nntp.pm,1090583,3153,246;41813
LWP/Protocol/nogo.pm,1093765,409,247;41939
LWP/RobotUA.pm,1094197,3898,248;41958
LWP/Simple.pm,1098117,1955,249;42134
LWP/UserAgent.pm,1100097,28316,250;42230
Lingua/EN/Numbers/Ordinate.pm,1128451,724,251;43228
Lingua/EN/PluralToSingular.pm,1129213,5931,252;43267
Locale/Messages.pm,1135171,7938,253;43679
Locale/Recode.pm,1143134,2671,254;44089
Locale/Recode/_Aliases.pm,1145839,23009,255;44235
Locale/Recode/_Conversions.pm,1168886,8557,256;44921
Locale/RecodeData.pm,1177472,534,257;45284
Locale/RecodeData/ASMO_449.pm,1178044,12115,258;45326
Locale/RecodeData/ATARI_ST.pm,1190197,15075,259;46015
Locale/RecodeData/ATARI_ST_EURO.pm,1205315,15080,260;46840
Locale/RecodeData/CP10007.pm,1220432,15082,261;47665
Locale/RecodeData/CP1250.pm,1235550,14958,262;48490
Locale/RecodeData/CP1251.pm,1250544,15054,263;49310
Locale/RecodeData/CP1252.pm,1265634,14958,264;50134
Locale/RecodeData/CP1253.pm,1280628,14686,265;50954
Locale/RecodeData/CP1254.pm,1295350,14912,266;51762
Locale/RecodeData/CP1256.pm,1310298,15089,267;52580
Locale/RecodeData/CP1257.pm,1325423,14797,268;53405
Locale/RecodeData/CSN_369103.pm,1340260,15009,269;54218
Locale/RecodeData/CWI.pm,1355302,15262,270;55043
Locale/RecodeData/DEC_MCS.pm,1370601,14661,271;55868
Locale/RecodeData/EBCDIC_AT_DE.pm,1385304,12835,272;56678
Locale/RecodeData/EBCDIC_AT_DE_A.pm,1398183,12742,273;57407
Locale/RecodeData/EBCDIC_CA_FR.pm,1410967,13314,274;58131
Locale/RecodeData/EBCDIC_DK_NO.pm,1424323,12835,275;58881
Locale/RecodeData/EBCDIC_DK_NO_A.pm,1437202,12742,276;59610
Locale/RecodeData/EBCDIC_ES.pm,1449983,12828,277;60334
Locale/RecodeData/EBCDIC_ES_A.pm,1462852,12735,278;61063
Locale/RecodeData/EBCDIC_ES_S.pm,1475628,12822,279;61787
Locale/RecodeData/EBCDIC_FI_SE.pm,1488492,12847,280;62516
Locale/RecodeData/EBCDIC_FI_SE_A.pm,1501383,12742,281;63245
Locale/RecodeData/EBCDIC_FR.pm,1514164,12836,282;63969
Locale/RecodeData/EBCDIC_IS_FRISS.pm,1527045,12493,283;64698
Locale/RecodeData/EBCDIC_IT.pm,1539577,12840,284;65412
Locale/RecodeData/EBCDIC_PT.pm,1552456,12828,285;66141
Locale/RecodeData/EBCDIC_UK.pm,1565323,12820,286;66870
Locale/RecodeData/EBCDIC_US.pm,1578182,12812,287;67599
Locale/RecodeData/ECMA_CYRILLIC.pm,1591037,15016,288;68328
Locale/RecodeData/GEORGIAN_ACADEMY.pm,1606099,15235,289;69153
Locale/RecodeData/GEORGIAN_PS.pm,1621375,15226,290;69978
Locale/RecodeData/GOST_19768_74.pm,1636644,14368,291;70803
Locale/RecodeData/GREEK7.pm,1651048,12212,292;71600
Locale/RecodeData/GREEK7_OLD.pm,1663300,12310,293;72294
Locale/RecodeData/GREEK_CCITT.pm,1675651,12194,294;72990
Locale/RecodeData/HP_ROMAN8.pm,1687884,14997,295;73683
Locale/RecodeData/IBM037.pm,1702917,15005,296;74507
Locale/RecodeData/IBM038.pm,1717958,12801,297;75332
Locale/RecodeData/IBM1004.pm,1730796,14863,298;76061
Locale/RecodeData/IBM1026.pm,1745696,15010,299;76877
Locale/RecodeData/IBM1047.pm,1760743,15006,300;77702
Locale/RecodeData/IBM256.pm,1775785,15021,301;78527
Locale/RecodeData/IBM273.pm,1790842,15009,302;79352
Locale/RecodeData/IBM274.pm,1805887,12821,303;80177
Locale/RecodeData/IBM275.pm,1818744,12829,304;80906
Locale/RecodeData/IBM277.pm,1831609,15009,305;81635
Locale/RecodeData/IBM278.pm,1846654,15009,306;82460
Locale/RecodeData/IBM280.pm,1861699,15009,307;83285
Locale/RecodeData/IBM281.pm,1876744,12821,308;84110
Locale/RecodeData/IBM284.pm,1889601,15009,309;84839
Locale/RecodeData/IBM285.pm,1904646,15009,310;85664
Locale/RecodeData/IBM290.pm,1919691,13990,311;86489
Locale/RecodeData/IBM297.pm,1933717,15009,312;87253
Locale/RecodeData/IBM420.pm,1948762,14955,313;88078
Locale/RecodeData/IBM423.pm,1963753,14803,314;88893
Locale/RecodeData/IBM424.pm,1978592,14116,315;89708
Locale/RecodeData/IBM437.pm,1992744,15253,316;90494
Locale/RecodeData/IBM500.pm,2008033,15005,317;91319
Locale/RecodeData/IBM850.pm,2023074,15125,318;92144
Locale/RecodeData/IBM851.pm,2038235,15098,319;92969
Locale/RecodeData/IBM852.pm,2053369,15121,320;93793
Locale/RecodeData/IBM855.pm,2068526,15125,321;94618
Locale/RecodeData/IBM857.pm,2083687,15052,322;95443
Locale/RecodeData/IBM860.pm,2098775,15249,323;96265
Locale/RecodeData/IBM861.pm,2114060,15253,324;97090
Locale/RecodeData/IBM862.pm,2129349,15253,325;97915
Locale/RecodeData/IBM863.pm,2144638,15253,326;98740
Locale/RecodeData/IBM864.pm,2159927,15227,327;99565
Locale/RecodeData/IBM865.pm,2175190,15253,328;100384
Locale/RecodeData/IBM866.pm,2190479,15213,329;101209
Locale/RecodeData/IBM868.pm,2205728,14654,330;102034
Locale/RecodeData/IBM869.pm,2220418,14926,331;102834
Locale/RecodeData/IBM870.pm,2235380,14752,332;103650
Locale/RecodeData/IBM871.pm,2250168,15005,333;104464
Locale/RecodeData/IBM874.pm,2265209,14676,334;105289
Locale/RecodeData/IBM875.pm,2279921,14864,335;106083
Locale/RecodeData/IBM880.pm,2294821,14799,336;106901
Locale/RecodeData/IBM891.pm,2309656,12061,337;107716
Locale/RecodeData/IBM903.pm,2321753,12061,338;108413
Locale/RecodeData/IBM904.pm,2333850,12130,339;109110
Locale/RecodeData/IBM905.pm,2346016,14798,340;109810
Locale/RecodeData/IBM918.pm,2360850,14503,341;110626
Locale/RecodeData/IEC_P27_1.pm,2375392,15212,342;111425
Locale/RecodeData/INIS.pm,2390638,11812,343;112250
Locale/RecodeData/INIS_8.pm,2402486,11237,344;112934
Locale/RecodeData/INIS_CYRILLIC.pm,2413766,12188,345;113575
Locale/RecodeData/ISO_10367_BOX.pm,2425997,13587,346;114260
Locale/RecodeData/ISO_2033_1983.pm,2439627,10580,347;115018
Locale/RecodeData/ISO_5427.pm,2450245,12319,348;115635
Locale/RecodeData/ISO_5427_EXT.pm,2462606,11235,349;116332
Locale/RecodeData/ISO_5428.pm,2473879,12004,350;116977
Locale/RecodeData/ISO_8859_1.pm,2485923,4631,351;117653
Locale/RecodeData/ISO_8859_10.pm,2490595,15014,352;117957
Locale/RecodeData/ISO_8859_11.pm,2505650,14342,353;118782
Locale/RecodeData/ISO_8859_13.pm,2520033,15026,354;119567
Locale/RecodeData/ISO_8859_14.pm,2535100,15098,355;120392
Locale/RecodeData/ISO_8859_15.pm,2550239,15014,356;121217
Locale/RecodeData/ISO_8859_16.pm,2565294,15022,357;122042
Locale/RecodeData/ISO_8859_2.pm,2580356,15009,358;122867
Locale/RecodeData/ISO_8859_3.pm,2595405,14848,359;123692
Locale/RecodeData/ISO_8859_4.pm,2610293,15009,360;124510
Locale/RecodeData/ISO_8859_5.pm,2625342,15013,361;125335
Locale/RecodeData/ISO_8859_6.pm,2640395,13974,362;126160
Locale/RecodeData/ISO_8859_7.pm,2654409,14883,363;126940
Locale/RecodeData/ISO_8859_8.pm,2669332,14193,364;127759
Locale/RecodeData/ISO_8859_9.pm,2683565,15009,365;128548
Locale/RecodeData/KOI8_R.pm,2698610,15229,366;129373
Locale/RecodeData/KOI8_RU.pm,2713876,15190,367;130198
Locale/RecodeData/KOI8_T.pm,2729102,14636,368;131023
Locale/RecodeData/KOI8_U.pm,2743774,15197,369;131829
Locale/RecodeData/KOI_8.pm,2759006,13509,370;132654
Locale/RecodeData/LATIN_GREEK.pm,2772556,12155,371;133414
Locale/RecodeData/LATIN_GREEK_1.pm,2784754,12120,372;134110
Locale/RecodeData/MACARABIC.pm,2796913,14414,373;134807
Locale/RecodeData/MACCROATIAN.pm,2811368,15103,374;135606
Locale/RecodeData/MACCYRILLIC.pm,2826512,15090,375;136430
Locale/RecodeData/MACGREEK.pm,2841640,15044,376;137255
Locale/RecodeData/MACHEBREW.pm,2856723,14098,377;138079
Locale/RecodeData/MACICELAND.pm,2870861,15090,378;138862
Locale/RecodeData/MACINTOSH.pm,2885990,15136,379;139686
Locale/RecodeData/MACROMANIA.pm,2901166,15106,380;140511
Locale/RecodeData/MACTHAI.pm,2916309,15336,381;141335
Locale/RecodeData/MACTURKISH.pm,2931685,15071,382;142154
Locale/RecodeData/MACUKRAINE.pm,2946796,15085,383;142977
Locale/RecodeData/MAC_IS.pm,2961917,15067,384;143802
Locale/RecodeData/MAC_SAMI.pm,2977022,15095,385;144625
Locale/RecodeData/MAC_UK.pm,2992153,15081,386;145450
Locale/RecodeData/NATS_DANO.pm,3007273,12128,387;146275
Locale/RecodeData/NATS_SEFI.pm,3019440,12120,388;146972
Locale/RecodeData/NEXTSTEP.pm,3031598,15029,389;147669
Locale/RecodeData/SAMI_WS2.pm,3046665,14886,390;148492
Locale/RecodeData/TIS_620.pm,3061588,14411,391;149310
Locale/RecodeData/US_ASCII.pm,3076037,816,392;150094
Locale/RecodeData/UTF_8.pm,3076888,3052,393;150140
Locale/RecodeData/VISCII.pm,3079976,15389,394;150274
Locale/RecodeData/_Encode.pm,3095402,964,395;151099
Locale/TextDomain.pm,3096395,7048,396;151152
Locale/TextDomain/UTF8.pm,3103477,506,397;151497
Locale/Util.pm,3104006,21462,398;151524
Locale/gettext_dumb.pm,3125499,5589,399;152450
Locale/gettext_pp.pm,3131117,20371,400;152640
Locale/gettext_xs.pm,3151517,4198,401;153433
Log/Any.pm,3155734,2731,402;153614
Log/Any/Adapter.pm,3158492,367,403;153728
Log/Any/Adapter/Base.pm,3158891,772,404;153757
Log/Any/Adapter/File.pm,3159695,1925,405;153794
Log/Any/Adapter/Log4perl.pm,3161656,850,406;153861
Log/Any/Adapter/Null.pm,3162538,382,407;153903
Log/Any/Adapter/Screen.pm,3162954,3222,408;153926
Log/Any/Adapter/Stderr.pm,3166210,1229,409;154047
Log/Any/Adapter/Stdout.pm,3167473,1229,410;154097
Log/Any/Adapter/Test.pm,3168734,4762,411;154147
Log/Any/Adapter/Util.pm,3173528,3230,412;154344
Log/Any/App.pm,3176781,37247,413;154501
Log/Any/IfLOG.pm,3214053,1381,414;155598
Log/Any/Manager.pm,3215461,5286,415;155663
Log/Any/Proxy.pm,3220772,2544,416;155859
Log/Any/Proxy/Null.pm,3223346,937,417;155949
Log/Any/Proxy/Test.pm,3224313,499,418;155995
Log/Any/Test.pm,3224836,275,419;156026
Log/Dispatch.pm,3225135,5693,420;156042
Log/Dispatch/ApacheLog.pm,3230862,1089,421;156308
Log/Dispatch/ArrayWithLimits.pm,3231991,890,422;156369
Log/Dispatch/Base.pm,3232910,864,423;156412
Log/Dispatch/Code.pm,3233803,652,424;156464
Log/Dispatch/Dir.pm,3234483,5665,425;156506
Log/Dispatch/Email.pm,3240178,2361,426;156712
Log/Dispatch/Email/MIMELite.pm,3242578,635,427;156820
Log/Dispatch/Email/MailSend.pm,3243252,807,428;156857
Log/Dispatch/Email/MailSender.pm,3244100,2071,429;156901
Log/Dispatch/Email/MailSendmail.pm,3246214,627,430;156985
Log/Dispatch/File.pm,3246870,3734,431;157021
Log/Dispatch/File/Locked.pm,3250640,1016,432;157193
Log/Dispatch/FileWriteRotate.pm,3251696,977,433;157242
Log/Dispatch/Handle.pm,3252704,726,434;157290
Log/Dispatch/Null.pm,3253459,368,435;157331
Log/Dispatch/Output.pm,3253858,3685,436;157360
Log/Dispatch/Screen.pm,3257574,1048,437;157529
Log/Dispatch/Syslog.pm,3258653,2595,438;157587
Log/Dispatch/Vars.pm,3261277,904,439;157710
Log/Log4perl.pm,3262205,13496,440;157769
Log/Log4perl/Appender.pm,3275734,5408,441;158272
Log/Log4perl/Appender/Buffer.pm,3281182,2315,442;158499
Log/Log4perl/Appender/DBI.pm,3283534,7150,443;158605
Log/Log4perl/Appender/File.pm,3290722,7352,444;158885
Log/Log4perl/Appender/Limit.pm,3298113,3445,445;159172
Log/Log4perl/Appender/RRDs.pm,3301596,751,446;159323
Log/Log4perl/Appender/Screen.pm,3302387,687,447;159363
Log/Log4perl/Appender/ScreenColoredLevels.pm,3303127,1633,448;159405
Log/Log4perl/Appender/Socket.pm,3304800,1981,449;159475
Log/Log4perl/Appender/String.pm,3306821,599,450;159565
Log/Log4perl/Appender/Synchronized.pm,3307466,1642,451;159604
Log/Log4perl/Appender/TestArrayBuffer.pm,3309157,428,452;159678
Log/Log4perl/Appender/TestBuffer.pm,3309629,1402,453;159697
Log/Log4perl/Appender/TestFileCreeper.pm,3311080,418,454;159780
Log/Log4perl/Catalyst.pm,3311531,3471,455;159806
Log/Log4perl/Config.pm,3315033,22937,456;159953
Log/Log4perl/Config/BaseConfigurator.pm,3338018,2716,457;160748
Log/Log4perl/Config/DOMConfigurator.pm,3340781,12963,458;160870
Log/Log4perl/Config/PropertyConfigurator.pm,3353796,3053,459;161339
Log/Log4perl/Config/Watch.pm,3356886,4454,460;161463
Log/Log4perl/DateFormat.pm,3361375,4903,461;161641
Log/Log4perl/Filter.pm,3366309,1486,462;161842
Log/Log4perl/Filter/Boolean.pm,3367834,1776,463;161920
Log/Log4perl/Filter/LevelMatch.pm,3369652,1120,464;162009
Log/Log4perl/Filter/LevelRange.pm,3370814,1267,465;162061
Log/Log4perl/Filter/MDC.pm,3372116,664,466;162115
Log/Log4perl/Filter/StringMatch.pm,3372823,1355,467;162153
Log/Log4perl/InternalDebug.pm,3374216,1093,468;162212
Log/Log4perl/JavaMap.pm,3375341,1901,469;162275
Log/Log4perl/JavaMap/ConsoleAppender.pm,3377290,762,470;162336
Log/Log4perl/JavaMap/FileAppender.pm,3378097,1681,471;162371
Log/Log4perl/JavaMap/JDBCAppender.pm,3379823,1743,472;162425
Log/Log4perl/JavaMap/NTEventLogAppender.pm,3381617,616,473;162481
Log/Log4perl/JavaMap/RollingFileAppender.pm,3382285,2238,474;162513
Log/Log4perl/JavaMap/SyslogAppender.pm,3384570,949,475;162588
Log/Log4perl/JavaMap/TestBuffer.pm,3385562,386,476;162631
Log/Log4perl/Layout.pm,3385979,479,477;162649
Log/Log4perl/Layout/NoopLayout.pm,3386500,346,478;162680
Log/Log4perl/Layout/PatternLayout.pm,3386891,13624,479;162706
Log/Log4perl/Layout/PatternLayout/Multiline.pm,3400570,537,480;163177
Log/Log4perl/Layout/SimpleLayout.pm,3401151,563,481;163203
Log/Log4perl/Level.pm,3401744,3795,482;163238
Log/Log4perl/Logger.pm,3405570,22552,483;163417
Log/Log4perl/MDC.pm,3428150,611,484;164321
Log/Log4perl/NDC.pm,3428789,629,485;164368
Log/Log4perl/Resurrector.pm,3429454,2131,486;164413
Log/Log4perl/Util.pm,3431614,1335,487;164513
Log/Log4perl/Util/Semaphore.pm,3432988,4172,488;164578
Log/Log4perl/Util/TimeTracker.pm,3437201,2363,489;164748
Method/Generate/Accessor.pm,3439600,19595,490;164865
Method/Generate/BuildAll.pm,3459231,1031,491;165517
Method/Generate/Constructor.pm,3460301,8243,492;165559
Method/Generate/DemolishAll.pm,3468583,1368,493;165833
Mo.pm,3469965,591,494;165885
Mo/Golf.pm,3470575,7519,495;165889
Mo/Inline.pm,3478115,2047,496;166106
Mo/Moose.pm,3480182,533,497;166192
Mo/Mouse.pm,3480735,563,498;166197
Mo/build.pm,3481318,248,499;166202
Mo/builder.pm,3481588,338,500;166206
Mo/chain.pm,3481946,216,501;166210
Mo/coerce.pm,3482183,330,502;166214
Mo/default.pm,3482535,435,503;166218
Mo/exporter.pm,3482993,176,504;166222
Mo/import.pm,3483190,185,505;166226
Mo/importer.pm,3483398,207,506;166230
Mo/is.pm,3483622,228,507;166234
Mo/nonlazy.pm,3483872,129,508;166238
Mo/option.pm,3484022,259,509;166242
Mo/required.pm,3484304,340,510;166246
Mo/xs.pm,3484661,256,511;166250
Module/Implementation.pm,3484950,3386,512;166254
Module/Installed/Tiny.pm,3488369,3030,513;166395
Module/List.pm,3491422,2572,514;166512
Module/Path/More.pm,3494022,7446,515;166601
Module/Runtime.pm,3501494,3939,516;166858
Monkey/Patch/Action.pm,3505464,1545,517;167024
Monkey/Patch/Action/Handle.pm,3507047,2833,518;167086
Moo.pm,3509895,7314,519;167200
Moo/HandleMoose.pm,3517236,7368,520;167443
Moo/HandleMoose/FakeMetaClass.pm,3524645,998,521;167661
Moo/HandleMoose/_TypeMap.pm,3525679,1714,522;167695
Moo/Object.pm,3527415,1912,523;167771
Moo/Role.pm,3529347,12456,524;167846
Moo/_Utils.pm,3541825,3213,525;168286
Moo/_mro.pm,3545058,130,526;168409
Moo/_strictures.pm,3545215,290,527;168419
Moo/sification.pm,3545531,781,528;168437
Net/HTTP.pm,3546332,943,529;168471
Net/HTTP/Methods.pm,3547303,15208,530;168516
Net/HTTP/NB.pm,3562534,1120,531;169121
Net/HTTPS.pm,3563675,1751,532;169177
Nodejs/Util.pm,3565449,4944,533;169256
PERLANCAR/Module/List.pm,3570426,2921,534;169442
Package/MoreUtil.pm,3573375,2070,535;169524
Package/Stash.pm,3575470,896,536;169623
Package/Stash/PP.pm,3576394,10746,537;169664
Params/Validate.pm,3587167,1200,538;170048
Params/Validate/Constants.pm,3588404,611,539;170116
Params/Validate/PP.pm,3589045,18330,540;170155
Params/Validate/XS.pm,3607405,993,541;170835
Parse/VarName.pm,3608423,1629,542;170886
Perinci/Access.pm,3610078,3061,543;170962
Perinci/Access/Base.pm,3613170,960,544;171065
Perinci/Access/HTTP/Client.pm,3614168,7824,545;171111
Perinci/Access/Lite.pm,3622023,6811,546;171367
Perinci/Access/Perl.pm,3628865,706,547;171564
Perinci/Access/Schemeless.pm,3629608,26533,548;171605
Perinci/Access/Simple/Client.pm,3656181,10168,549;172576
Perinci/AccessUtil.pm,3666379,2450,550;172892
Perinci/CmdLine/Base.pm,3668861,43460,551;172980
Perinci/CmdLine/Classic.pm,3712356,21743,552;174326
Perinci/CmdLine/Classic/ColorTheme/Default.pm,3734153,971,553;175061
Perinci/CmdLine/Classic/Role/Help.pm,3735169,14700,554;175107
Perinci/CmdLine/Help.pm,3749901,6914,555;175582
Perinci/CmdLine/Lite.pm,3756847,13407,556;175805
Perinci/CmdLine/Util/Config.pm,3770293,7499,557;176279
Perinci/Object.pm,3777818,1131,558;176541
Perinci/Object/EnvResult.pm,3778985,1591,559;176599
Perinci/Object/EnvResultMulti.pm,3780617,1060,560;176684
Perinci/Object/EnvResultTable.pm,3781718,359,561;176734
Perinci/Object/Function.pm,3782112,1337,562;176755
Perinci/Object/Metadata.pm,3783484,2643,563;176819
Perinci/Object/Package.pm,3786161,222,564;176954
Perinci/Object/ResMeta.pm,3786417,222,565;176971
Perinci/Object/Variable.pm,3786674,224,566;176988
Perinci/Result/Format.pm,3786931,5475,567;177005
Perinci/Result/Format/Lite.pm,3792444,16131,568;177178
Perinci/Sub/Complete.pm,3808607,46145,569;177608
Perinci/Sub/ConvertArgs/Argv.pm,3854792,4241,570;178819
Perinci/Sub/ConvertArgs/Array.pm,3859074,2051,571;178961
Perinci/Sub/DepChecker.pm,3861159,5057,572;179042
Perinci/Sub/GetArgs/Argv.pm,3866252,38098,573;179231
Perinci/Sub/GetArgs/Array.pm,3904387,3800,574;180280
Perinci/Sub/Normalize.pm,3908220,4885,575;180411
Perinci/Sub/To/CLIDocData.pm,3913142,16158,576;180563
Perinci/Sub/Util.pm,3929328,12303,577;181013
Perinci/Sub/Util/Args.pm,3941664,3131,578;181451
Perinci/Sub/Util/ResObj.pm,3944830,243,579;181568
Perinci/Sub/Util/Sort.pm,3945106,463,580;181583
Perinci/Sub/Wrapper.pm,3945600,45014,581;181612
Proc/ChildError.pm,3990641,1012,582;182930
Proc/PID/File.pm,3991678,3636,583;182980
Progress/Any.pm,3995338,13409,584;183167
Progress/Any/Output.pm,4008778,1286,585;183679
Progress/Any/Output/Null.pm,4010100,226,586;183743
Progress/Any/Output/TermProgressBarColor.pm,4010378,5087,587;183764
Regexp/Stringify.pm,4015493,2473,588;183958
Role/Tiny.pm,4017987,11598,589;184057
Role/Tiny/With.pm,4029611,297,590;184485
Sah/Schema/rinci/function_meta.pm,4029950,3632,591;184507
Sah/Schema/rinci/meta.pm,4033615,683,592;184645
Sah/Schema/rinci/result_meta.pm,4034338,611,593;184688
Sah/SchemaR/rinci/function_meta.pm,4034992,7833,594;184723
Sah/SchemaR/rinci/meta.pm,4042859,1990,595;184894
Sah/SchemaR/rinci/result_meta.pm,4044890,960,596;184953
Sah/Schemas/Rinci.pm,4045879,108,597;184994
Scalar/Util/Numeric/PP.pm,4046021,1353,598;185003
String/Elide/Parts.pm,4047404,4770,599;185073
String/LineNumber.pm,4052203,859,600;185226
String/PerlQuote.pm,4053090,890,601;185266
String/ShellQuote.pm,4054009,1822,602;185316
String/Wildcard/Bash.pm,4055863,2159,603;185430
Sub/Defer.pm,4058043,2979,604;185518
Sub/Delete.pm,4061044,1622,605;185634
Sub/Exporter/Progressive.pm,4062702,2888,606;185700
Sub/Quote.pm,4065611,6535,607;185794
Term/App/Role/Attrs.pm,4072177,6604,608;186021
Term/App/Roles.pm,4078807,101,609;186246
Term/Detect/Software.pm,4078940,6916,610;186255
Test/Config/IOD/Common.pm,4085890,6053,611;186456
Test/Data/Sah.pm,4091968,9810,612;186725
Test/Data/Sah/Human.pm,4101809,934,613;187034
Test/Data/Sah/Perl.pm,4102773,4123,614;187076
Test/Perinci/Sub/Wrapper.pm,4106932,8753,615;187201
Text/ANSI/BaseUtil.pm,4115715,21721,616;187419
Text/ANSI/Util.pm,4137462,903,617;188148
Text/ANSITable.pm,4138391,47459,618;188185
Text/ANSITable/BorderStyle/Default.pm,4185896,10020,619;189737
Text/ANSITable/ColorTheme/Default.pm,4195961,3078,620;190149
Text/ANSITable/StyleSet/AltRow.pm,4199081,1103,621;190255
Text/Table/Any.pm,4200210,4431,622;190301
Text/Table/Tiny.pm,4204668,2733,623;190422
Text/sprintfn.pm,4207426,3295,624;190521
Tie/Cache.pm,4210742,9555,625;190646
Tie/IxHash.pm,4220319,6075,626;191088
Time/Duration.pm,4226419,5577,627;191434
Try/Tiny.pm,4232016,3379,628;191638
URI.pm,4235410,6816,629;191800
URI/Escape.pm,4242248,1725,630;192130
URI/Find.pm,4243993,6881,631;192208
URI/Find/Schemeless.pm,4250905,11679,632;192502
URI/Heuristic.pm,4262609,3511,633;193233
URI/IRI.pm,4266139,731,634;193389
URI/QueryParam.pm,4266896,1928,635;193434
URI/Split.pm,4268845,1067,636;193525
URI/URL.pm,4269931,3546,637;193571
URI/WithBase.pm,4273501,2154,638;193749
URI/_foreign.pm,4275679,144,639;193859
URI/_generic.pm,4275847,5400,640;193870
URI/_idna.pm,4281268,1823,641;194116
URI/_ldap.pm,4283112,2811,642;194199
URI/_login.pm,4285945,160,643;194330
URI/_punycode.pm,4286130,3635,644;194342
URI/_query.pm,4289787,2428,645;194491
URI/_segment.pm,4292239,384,646;194584
URI/_server.pm,4292646,3737,647;194607
URI/_userpass.pm,4296408,1116,648;194774
URI/data.pm,4297544,1669,649;194830
URI/file.pm,4299233,2852,650;194908
URI/file/Base.pm,4302110,1579,651;195035
URI/file/FAT.pm,4303713,433,652;195120
URI/file/Mac.pm,4304170,2184,653;195147
URI/file/OS2.pm,4306378,497,654;195265
URI/file/QNX.pm,4306899,330,655;195296
URI/file/Unix.pm,4307254,981,656;195316
URI/file/Win32.pm,4308261,1707,657;195373
URI/ftp.pm,4309987,690,658;195459
URI/gopher.pm,4310699,1608,659;195498
URI/http.pm,4312327,479,660;195574
URI/https.pm,4312827,185,661;195602
URI/ldap.pm,4313032,290,662;195617
URI/ldapi.pm,4313343,497,663;195639
URI/ldaps.pm,4313861,185,664;195669
URI/mailto.pm,4314068,1191,665;195684
URI/mms.pm,4315278,164,666;195754
URI/news.pm,4315462,1227,667;195767
URI/nntp.pm,4316709,138,668;195834
URI/pop.pm,4316866,1254,669;195845
URI/rlogin.pm,4318142,168,670;195916
URI/rsync.pm,4318331,189,671;195929
URI/rtsp.pm,4318540,164,672;195943
URI/rtspu.pm,4318725,165,673;195956
URI/sftp.pm,4318910,135,674;195969
URI/sip.pm,4319064,1574,675;195980
URI/sips.pm,4320658,184,676;196059
URI/snews.pm,4320863,187,677;196074
URI/ssh.pm,4321069,186,678;196089
URI/telnet.pm,4321277,167,679;196105
URI/tn3270.pm,4321466,167,680;196118
URI/urn.pm,4321652,2153,681;196131
URI/urn/isbn.pm,4323829,2158,682;196234
URI/urn/oid.pm,4326010,320,683;196333
UUID/Random.pm,4326353,382,684;196354
WWW/RobotRules.pm,4326761,5070,685;196377
WWW/RobotRules/AnyDBM_File.pm,4331869,2677,686;196642
YAML.pm,4334562,2382,687;196773
YAML/Any.pm,4336964,2772,688;196869
YAML/Dumper.pm,4339759,15047,689;196991
YAML/Dumper/Base.pm,4354834,3495,690;197512
YAML/Error.pm,4358351,5882,691;197618
YAML/Loader.pm,4364256,21564,692;197807
YAML/Loader/Base.pm,4385848,1015,693;198505
YAML/Marshall.pm,4386888,914,694;198538
YAML/Mo.pm,4387821,3035,695;198585
YAML/Node.pm,4390877,4359,696;198656
YAML/Old.pm,4395256,2533,697;198871
YAML/Old/Dumper.pm,4397816,14625,698;198972
YAML/Old/Dumper/Base.pm,4412473,3367,699;199476
YAML/Old/Error.pm,4415866,5986,700;199579
YAML/Old/Loader.pm,4421879,21662,701;199770
YAML/Old/Loader/Base.pm,4443573,1025,702;200469
YAML/Old/Marshall.pm,4444627,939,703;200502
YAML/Old/Mo.pm,4445589,2688,704;200549
YAML/Old/Node.pm,4448302,4412,705;200621
YAML/Old/Tag.pm,4452738,240,706;200839
YAML/Old/Types.pm,4453004,5701,707;200858
YAML/Tag.pm,4458725,235,708;201075
YAML/Types.pm,4458982,5770,709;201094
experimental.pm,4464776,2970,710;201317
namespace/clean.pm,4467773,4594,711;201436
oo.pm,4472381,608,712;201624
strictures.pm,4473011,5366,713;201659
strictures/extra.pm,4478405,200,714;201902

### B/Hooks/EndOfScope.pm ###
#package B::Hooks::EndOfScope; 
#
#use strict;
#use warnings;
#
#our $VERSION = '0.21';
#
#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.21';
#
#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.21';
#
#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__
#
### Capture/Tiny.pm ###
#use 5.006;
#use strict;
#use warnings;
#package Capture::Tiny;
#our $VERSION = '0.44';
#use Carp ();
#use Exporter ();
#use IO::Handle ();
#use File::Spec ();
#use File::Temp qw/tempfile tmpnam/;
#use Scalar::Util qw/reftype blessed/;
#BEGIN {
#  local $@;
#  eval { require PerlIO; PerlIO->can('get_layers') }
#    or *PerlIO::get_layers = sub { return () };
#}
#
#
#my %api = (
#  capture         => [1,1,0,0],
#  capture_stdout  => [1,0,0,0],
#  capture_stderr  => [0,1,0,0],
#  capture_merged  => [1,1,1,0],
#  tee             => [1,1,0,1],
#  tee_stdout      => [1,0,0,1],
#  tee_stderr      => [0,1,0,1],
#  tee_merged      => [1,1,1,1],
#);
#
#for my $sub ( keys %api ) {
#  my $args = join q{, }, @{$api{$sub}};
#  eval "sub $sub(&;@) {unshift \@_, $args; goto \\&_capture_tee;}"; 
#}
#
#our @ISA = qw/Exporter/;
#our @EXPORT_OK = keys %api;
#our %EXPORT_TAGS = ( 'all' => \@EXPORT_OK );
#
#
#my $IS_WIN32 = $^O eq 'MSWin32';
#
#
#our $TIMEOUT = 30;
#
#my @cmd = ($^X, '-C0', '-e', <<'HERE');
#use Fcntl;
#$SIG{HUP}=sub{exit};
#if ( my $fn=shift ) {
#    sysopen(my $fh, qq{$fn}, O_WRONLY|O_CREAT|O_EXCL) or die $!;
#    print {$fh} $$;
#    close $fh;
#}
#my $buf; while (sysread(STDIN, $buf, 2048)) {
#    syswrite(STDOUT, $buf); syswrite(STDERR, $buf);
#}
#HERE
#
#
#sub _relayer {
#  my ($fh, $layers) = @_;
#
#  binmode( $fh, ":raw" );
#  while ( 1 < ( my $layers =()= PerlIO::get_layers( $fh, output => 1 ) ) ) {
#      binmode( $fh, ":pop" );
#  }
#  my @to_apply = @$layers;
#  shift @to_apply; 
#  binmode($fh, ":" . join(":",@to_apply));
#}
#
#sub _name {
#  my $glob = shift;
#  no strict 'refs'; 
#  return *{$glob}{NAME};
#}
#
#sub _open {
#  open $_[0], $_[1] or Carp::confess "Error from open(" . join(q{, }, @_) . "): $!";
#}
#
#sub _close {
#  close $_[0] or Carp::confess "Error from close(" . join(q{, }, @_) . "): $!";
#}
#
#my %dup; 
#my %proxy_count;
#sub _proxy_std {
#  my %proxies;
#  if ( ! defined fileno STDIN ) {
#    $proxy_count{stdin}++;
#    if (defined $dup{stdin}) {
#      _open \*STDIN, "<&=" . fileno($dup{stdin});
#    }
#    else {
#      _open \*STDIN, "<" . File::Spec->devnull;
#      _open $dup{stdin} = IO::Handle->new, "<&=STDIN";
#    }
#    $proxies{stdin} = \*STDIN;
#    binmode(STDIN, ':utf8') if $] >= 5.008; 
#  }
#  if ( ! defined fileno STDOUT ) {
#    $proxy_count{stdout}++;
#    if (defined $dup{stdout}) {
#      _open \*STDOUT, ">&=" . fileno($dup{stdout});
#    }
#    else {
#      _open \*STDOUT, ">" . File::Spec->devnull;
#      _open $dup{stdout} = IO::Handle->new, ">&=STDOUT";
#    }
#    $proxies{stdout} = \*STDOUT;
#    binmode(STDOUT, ':utf8') if $] >= 5.008; 
#  }
#  if ( ! defined fileno STDERR ) {
#    $proxy_count{stderr}++;
#    if (defined $dup{stderr}) {
#      _open \*STDERR, ">&=" . fileno($dup{stderr});
#    }
#    else {
#      _open \*STDERR, ">" . File::Spec->devnull;
#      _open $dup{stderr} = IO::Handle->new, ">&=STDERR";
#    }
#    $proxies{stderr} = \*STDERR;
#    binmode(STDERR, ':utf8') if $] >= 5.008; 
#  }
#  return %proxies;
#}
#
#sub _unproxy {
#  my (%proxies) = @_;
#  for my $p ( keys %proxies ) {
#    $proxy_count{$p}--;
#    if ( ! $proxy_count{$p} ) {
#      _close $proxies{$p};
#      _close $dup{$p} unless $] < 5.008; 
#      delete $dup{$p};
#    }
#  }
#}
#
#sub _copy_std {
#  my %handles;
#  for my $h ( qw/stdout stderr stdin/ ) {
#    next if $h eq 'stdin' && ! $IS_WIN32; 
#    my $redir = $h eq 'stdin' ? "<&" : ">&";
#    _open $handles{$h} = IO::Handle->new(), $redir . uc($h); 
#  }
#  return \%handles;
#}
#
#sub _open_std {
#  my ($handles) = @_;
#  _open \*STDIN, "<&" . fileno $handles->{stdin} if defined $handles->{stdin};
#  _open \*STDOUT, ">&" . fileno $handles->{stdout} if defined $handles->{stdout};
#  _open \*STDERR, ">&" . fileno $handles->{stderr} if defined $handles->{stderr};
#}
#
#
#sub _start_tee {
#  my ($which, $stash) = @_; 
#  $stash->{$_}{$which} = IO::Handle->new for qw/tee reader/;
#  pipe $stash->{reader}{$which}, $stash->{tee}{$which};
#  select((select($stash->{tee}{$which}), $|=1)[0]); 
#  $stash->{new}{$which} = $stash->{tee}{$which};
#  $stash->{child}{$which} = {
#    stdin   => $stash->{reader}{$which},
#    stdout  => $stash->{old}{$which},
#    stderr  => $stash->{capture}{$which},
#  };
#  $stash->{flag_files}{$which} = scalar tmpnam();
#  if ( $IS_WIN32 ) {
#    my $old_eval_err=$@;
#    undef $@;
#
#    eval "use Win32API::File qw/GetOsFHandle SetHandleInformation fileLastError HANDLE_FLAG_INHERIT INVALID_HANDLE_VALUE/ ";
#    my $os_fhandle = GetOsFHandle( $stash->{tee}{$which} );
#    my $result = SetHandleInformation( $os_fhandle, HANDLE_FLAG_INHERIT(), 0);
#    _open_std( $stash->{child}{$which} );
#    $stash->{pid}{$which} = system(1, @cmd, $stash->{flag_files}{$which});
#    $@=$old_eval_err;
#  }
#  else { 
#    _fork_exec( $which, $stash );
#  }
#}
#
#sub _fork_exec {
#  my ($which, $stash) = @_; 
#  my $pid = fork;
#  if ( not defined $pid ) {
#    Carp::confess "Couldn't fork(): $!";
#  }
#  elsif ($pid == 0) { 
#    untie *STDIN; untie *STDOUT; untie *STDERR;
#    _close $stash->{tee}{$which};
#    _open_std( $stash->{child}{$which} );
#    exec @cmd, $stash->{flag_files}{$which};
#  }
#  $stash->{pid}{$which} = $pid
#}
#
#my $have_usleep = eval "use Time::HiRes 'usleep'; 1";
#sub _files_exist {
#  return 1 if @_ == grep { -f } @_;
#  Time::HiRes::usleep(1000) if $have_usleep;
#  return 0;
#}
#
#sub _wait_for_tees {
#  my ($stash) = @_;
#  my $start = time;
#  my @files = values %{$stash->{flag_files}};
#  my $timeout = defined $ENV{PERL_CAPTURE_TINY_TIMEOUT}
#              ? $ENV{PERL_CAPTURE_TINY_TIMEOUT} : $TIMEOUT;
#  1 until _files_exist(@files) || ($timeout && (time - $start > $timeout));
#  Carp::confess "Timed out waiting for subprocesses to start" if ! _files_exist(@files);
#  unlink $_ for @files;
#}
#
#sub _kill_tees {
#  my ($stash) = @_;
#  if ( $IS_WIN32 ) {
#    close($_) for values %{ $stash->{tee} };
#    my $start = time;
#    1 until wait == -1 || (time - $start > 30);
#  }
#  else {
#    _close $_ for values %{ $stash->{tee} };
#    waitpid $_, 0 for values %{ $stash->{pid} };
#  }
#}
#
#sub _slurp {
#  my ($name, $stash) = @_;
#  my ($fh, $pos) = map { $stash->{$_}{$name} } qw/capture pos/;
#  seek( $fh, $pos, 0 ) or die "Couldn't seek on capture handle for $name\n";
#  my $text = do { local $/; scalar readline $fh };
#  return defined($text) ? $text : "";
#}
#
#
#sub _capture_tee {
#  my ($do_stdout, $do_stderr, $do_merge, $do_tee, $code, @opts) = @_;
#  my %do = ($do_stdout ? (stdout => 1) : (),  $do_stderr ? (stderr => 1) : ());
#  Carp::confess("Custom capture options must be given as key/value pairs\n")
#    unless @opts % 2 == 0;
#  my $stash = { capture => { @opts } };
#  for ( keys %{$stash->{capture}} ) {
#    my $fh = $stash->{capture}{$_};
#    Carp::confess "Custom handle for $_ must be seekable\n"
#      unless ref($fh) eq 'GLOB' || (blessed($fh) && $fh->isa("IO::Seekable"));
#  }
#  local *CT_ORIG_STDIN  = *STDIN ;
#  local *CT_ORIG_STDOUT = *STDOUT;
#  local *CT_ORIG_STDERR = *STDERR;
#  my %layers = (
#    stdin   => [PerlIO::get_layers(\*STDIN) ],
#    stdout  => [PerlIO::get_layers(\*STDOUT, output => 1)],
#    stderr  => [PerlIO::get_layers(\*STDERR, output => 1)],
#  );
#  $layers{stdout} = [PerlIO::get_layers(tied *STDOUT)]
#    if tied(*STDOUT) && (reftype tied *STDOUT eq 'GLOB');
#  $layers{stderr} = [PerlIO::get_layers(tied *STDERR)]
#    if tied(*STDERR) && (reftype tied *STDERR eq 'GLOB');
#  my %localize;
#  $localize{stdin}++,  local(*STDIN)
#    if grep { $_ eq 'scalar' } @{$layers{stdin}};
#  $localize{stdout}++, local(*STDOUT)
#    if $do_stdout && grep { $_ eq 'scalar' } @{$layers{stdout}};
#  $localize{stderr}++, local(*STDERR)
#    if ($do_stderr || $do_merge) && grep { $_ eq 'scalar' } @{$layers{stderr}};
#  $localize{stdin}++, local(*STDIN), _open( \*STDIN, "<&=0")
#    if tied *STDIN && $] >= 5.008;
#  $localize{stdout}++, local(*STDOUT), _open( \*STDOUT, ">&=1")
#    if $do_stdout && tied *STDOUT && $] >= 5.008;
#  $localize{stderr}++, local(*STDERR), _open( \*STDERR, ">&=2")
#    if ($do_stderr || $do_merge) && tied *STDERR && $] >= 5.008;
#  my %proxy_std = _proxy_std();
#  $layers{stdout} = [PerlIO::get_layers(\*STDOUT, output => 1)] if $proxy_std{stdout};
#  $layers{stderr} = [PerlIO::get_layers(\*STDERR, output => 1)] if $proxy_std{stderr};
#  $stash->{old} = _copy_std();
#  $stash->{new} = { %{$stash->{old}} }; 
#  for ( keys %do ) {
#    $stash->{new}{$_} = ($stash->{capture}{$_} ||= File::Temp->new);
#    seek( $stash->{capture}{$_}, 0, 2 ) or die "Could not seek on capture handle for $_\n";
#    $stash->{pos}{$_} = tell $stash->{capture}{$_};
#    _start_tee( $_ => $stash ) if $do_tee; 
#  }
#  _wait_for_tees( $stash ) if $do_tee;
#  $stash->{new}{stderr} = $stash->{new}{stdout} if $do_merge;
#  _open_std( $stash->{new} );
#  my ($exit_code, $inner_error, $outer_error, $orig_pid, @result);
#  {
#    $orig_pid = $$;
#    local *STDIN = *CT_ORIG_STDIN if $localize{stdin}; 
#    _relayer(\*STDOUT, $layers{stdout}) if $do_stdout;
#    _relayer(\*STDERR, $layers{stderr}) if $do_stderr;
#    my $old_eval_err=$@;
#    undef $@;
#    eval { @result = $code->(); $inner_error = $@ };
#    $exit_code = $?; 
#    $outer_error = $@; 
#    STDOUT->flush if $do_stdout;
#    STDERR->flush if $do_stderr;
#    $@ = $old_eval_err;
#  }
#  _open_std( $stash->{old} );
#  _close( $_ ) for values %{$stash->{old}}; 
#  _relayer(\*STDOUT, $layers{stdout}) if $do_stdout;
#  _relayer(\*STDERR, $layers{stderr}) if $do_stderr;
#  _unproxy( %proxy_std );
#  _kill_tees( $stash ) if $do_tee;
#  my %got;
#  if ( $orig_pid == $$ and ( defined wantarray or ($do_tee && keys %localize) ) ) {
#    for ( keys %do ) {
#      _relayer($stash->{capture}{$_}, $layers{$_});
#      $got{$_} = _slurp($_, $stash);
#    }
#    print CT_ORIG_STDOUT $got{stdout}
#      if $do_stdout && $do_tee && $localize{stdout};
#    print CT_ORIG_STDERR $got{stderr}
#      if $do_stderr && $do_tee && $localize{stderr};
#  }
#  $? = $exit_code;
#  $@ = $inner_error if $inner_error;
#  die $outer_error if $outer_error;
#  return unless defined wantarray;
#  my @return;
#  push @return, $got{stdout} if $do_stdout;
#  push @return, $got{stderr} if $do_stderr && ! $do_merge;
#  push @return, @result;
#  return wantarray ? @return : $return[0];
#}
#
#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; 
#
#our $VERSION = '2.12';
#
#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 = '2016-10-04'; 
#our $VERSION = '0.15'; 
#
#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} && !$ENV{COLOR}) {
#                $_color_depth = 0;
#                last;
#            }
#            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);
#    } elsif ($cd >= 16) {
#        rgb_to_ansi16_fg_code($rgb);
#    } else {
#        "";
#    }
#}
#
#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/Bash.pm ###
#package Complete::Bash;
#
#our $DATE = '2016-12-28'; 
#our $VERSION = '0.31'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#require Exporter;
#our @ISA = qw(Exporter);
#our @EXPORT_OK = qw(
#                       point
#                       parse_cmdline
#                       join_wordbreak_words
#                       format_completion
#               );
#
#our %SPEC;
#
#$SPEC{':package'} = {
#    v => 1.1,
#    summary => 'Completion routines for bash shell',
#};
#
#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{point} = {
#    v => 1.1,
#    summary => 'Return line with point marked by a marker',
#    description => <<'_',
#
#This is a utility function useful for testing/debugging. `parse_cmdline()`
#expects a command-line and a cursor position (`$line`, `$point`). This routine
#expects `$line` with a marker character (by default it's the caret, `^`) and
#return (`$line`, `$point`) to feed to `parse_cmdline()`.
#
#Example:
#
#    point("^foo") # => ("foo", 0)
#    point("fo^o") # => ("foo", 2)
#
#_
#    args_as => 'array',
#    args => {
#        cmdline => {
#            summary => 'Command-line which contains a marker character',
#            schema => 'str*',
#            pos => 0,
#        },
#        marker => {
#            summary => 'Marker character',
#            schema => ['str*', len=>1],
#            default => '^',
#            pos => 1,
#        },
#    },
#    result_naked => 1,
#};
#sub point {
#    my ($line, $marker) = @_;
#    $marker //= '^';
#
#    my $point = index($line, $marker);
#    die "BUG: No marker '$marker' in line <$line>" unless $point >= 0;
#    $line =~ s/\Q$marker\E//;
#    ($line, $point);
#}
#
#$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; this comparison is made against
#bash versions 4.2-4.3):
#
#1) quotes and backslashes are stripped (bash's `COMP_WORDS` contains all the
#   quotes and backslashes);
#
#2) quoted phrase that contains spaces, or phrase that contains escaped spaces is
#   parsed as a single word. For example:
#
#    command "First argument" Second\ argument
#
#   bash would split it as (represented as Perl):
#
#    ["command", "\"First", "argument\"", "Second\\", "argument"]
#
#   which is not very convenient. We parse it into:
#
#    ["command", "First argument", "Second argument"]
#
#3) 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.
#
#4) tildes (`~`) are expanded with user's home directory except for the current
#   word (bash does not perform tilde expansion for `COMP_WORDS`);
#
#Caveats:
#
#* Like bash, we group non-whitespace word-breaking characters into its own word.
#  By default `COMP_WORDBREAKS` is:
#
#    "'@><=;|&(:
#
#  So if raw command-line is:
#
#    command --foo=bar http://example.com:80 mail@example.org Foo::Bar
#
#  then the parse result will be:
#
#    ["command", "--foo", "=", "bar", "http", ":", "//example.com", ":", "80", "Foo", "::", "Bar"]
#
#  which is annoying sometimes. But we follow bash here so we can more easily
#  accept input from a joined `COMP_WORDS` if we write completion bash functions,
#  e.g. (in the example, `foo` is a Perl script):
#
#    _foo ()
#    {
#        local words=(${COMP_CWORDS[@]})
#        # add things to words, etc
#        local point=... # calculate the new point
#        COMPREPLY=( `COMP_LINE="foo ${words[@]}" COMP_POINT=$point foo` )
#    }
#
#  To avoid these word-breaking characters to be split/grouped, we can escape
#  them with backslash or quote them, e.g.:
#
#    command "http://example.com:80" Foo\:\:Bar
#
#  which bash will parse as:
#
#    ["command", "\"http://example.com:80\"", "Foo\\:\\:Bar"]
#
#  and we parse as:
#
#    ["command", "http://example.com:80", "Foo::Bar"]
#
#* Due to the way bash parses the command line (see above), the two below are
#  equivalent:
#
#    % cmd --foo=bar
#    % cmd --foo = bar
#
#Because they both expand to `['--foo', '=', 'bar']`. But obviously
#<pm: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,
#        },
#        opts => {
#            summary => 'Options',
#            schema => 'hash*',
#            description => <<'_',
#
#Optional. Known options:
#
#* `truncate_current_word` (bool). If set to 1, will truncate current word to the
#  position of cursor, for example (`^` marks the position of cursor):
#  `--vers^oo` to `--vers` instead of `--versoo`. This is more convenient when
#  doing tab completion.
#
#_
#            schema => 'hash*',
#            pos => 2,
#        },
#    },
#    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, roughly 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, $opts) = @_;
#
#    $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
#                  ([\@><=|&\(:]+) |                                      #  10) non-whitespace word-breaking characters
#                  \s+
#              )!
#                  $pos += length($1);
#                  #say "D: \$1=<$1> \$2=<$3> \$3=<$3> \$4=<$4> \$5=<$5> \$6=<$6> \$7=<$7> \$8=<$8> \$9=<$9> \$10=<$10>";
#                  #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;
#                      }
#                      #say "D:is_cur_word=$is_cur_word";
#                      $chunk =
#                          $2 ? _add_double_quoted($3, $is_cur_word) :
#                              $5 ? _add_single_quoted($6) :
#                              _add_unquoted($8, $is_cur_word, $after_ws);
#                      if ($opts && $opts->{truncate_current_word} &&
#                              $is_cur_word && $pos > $point) {
#                          $chunk = substr(
#                              $chunk, 0, length($chunk)-($pos_min_ws-$point));
#                          #say "D:truncating current word to <$chunk>";
#                      }
#                      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 ($10) {
#                      # non-whitespace word-breaking characters
#                      push @words, $10;
#                      $after_ws = 1;
#                  } else {
#                      # whitespace
#                      $after_ws = 1;
#                  }
#    !egx;
#
#    $cword //= @words;
#    $words[$cword] //= '';
#
#    [\@words, $cword];
#}
#
#$SPEC{join_wordbreak_words} = {
#    v => 1.1,
#    summary => 'Post-process parse_cmdline() result by joining some words',
#    description => <<'_',
#
#`parse_cmdline()`, like bash, splits some characters that are considered as
#word-breaking characters:
#
#    "'@><=;|&(:
#
#So if command-line is:
#
#    command -MData::Dump bob@example.org
#
#then they will be parsed as:
#
#    ["command", "-MData", "::", "Dump", "bob", '@', "example.org"]
#
#Normally in Perl applications, we want `:`, `@` to be part of word. So this
#routine will convert the above into:
#
#    ["command", "-MData::Dump", 'bob@example.org']
#
#_
#};
#sub join_wordbreak_words {
#    my ($words, $cword) = @_;
#    my $new_words = [];
#    my $i = -1;
#    while (++$i < @$words) {
#        my $w = $words->[$i];
#        if ($w =~ /\A[\@=:]+\z/) {
#            if (@$new_words and $#$new_words != $cword) {
#                $new_words->[-1] .= $w;
#                $cword-- if $cword >= $i || $cword >= @$new_words;
#            } else {
#                push @$new_words, $w;
#            }
#            if ($i+1 < @$words) {
#                $i++;
#                $new_words->[-1] .= $words->[$i];
#                $cword-- if $cword >= $i || $cword >= @$new_words;
#            }
#        } else {
#            push @$new_words, $w;
#        }
#    }
#    [$new_words, $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/Common.pm ###
#package Complete::Common;
#
#our $DATE = '2016-01-05'; 
#our $VERSION = '0.22'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(
#                       %arg_word
#               );
#
#our %EXPORT_TAGS = (
#    all => \@EXPORT_OK
#);
#
#our %arg_word = (
#    word => {
#        summary => 'Word to complete',
#        schema => ['str', default=>''],
#        pos=>0,
#        req=>1,
#    },
#);
#
#our $OPT_CI          = ($ENV{COMPLETE_OPT_CI}          // 1) ? 1:0;
#our $OPT_WORD_MODE   = ($ENV{COMPLETE_OPT_WORD_MODE}   // 1) ? 1:0;
#our $OPT_CHAR_MODE   = ($ENV{COMPLETE_OPT_CHAR_MODE}   // 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/Env.pm ###
#package Complete::Env;
#
#our $DATE = '2016-10-18'; 
#our $VERSION = '0.39'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Complete::Common qw(:all);
#
#require Exporter;
#our @ISA = qw(Exporter);
#our @EXPORT_OK = qw(
#                       complete_env
#                       complete_env_elem
#                       complete_path_env_elem
#               );
#
#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 },
#    },
#    result_naked => 1,
#    result => {
#        schema => 'array',
#    },
#};
#sub complete_env {
#    require Complete::Util;
#
#    my %args  = @_;
#    my $word     = $args{word} // "";
#    if ($word =~ /^\$/) {
#        Complete::Util::complete_array_elem(
#            word=>$word, array=>[map {"\$$_"} keys %ENV],
#        );
#    } else {
#        Complete::Util::complete_array_elem(
#            word=>$word, array=>[keys %ENV],
#        );
#    }
#}
#
#$SPEC{complete_env_elem} = {
#    v => 1.1,
#    summary => 'Complete from elements of an environment variable',
#    description => <<'_',
#
#An environment variable like PATH contains colon- (or, on Windows, semicolon-)
#separated elements. This routine complete from the elements of such variable.
#
#_
#    args => {
#        word     => { schema=>[str=>{default=>''}], pos=>0, req=>1 },
#        env      => {
#            summary => 'Name of environment variable to use',
#            schema  => 'str*',
#            req => 1,
#            pos => 1,
#        },
#    },
#    result_naked => 1,
#    result => {
#        schema => 'array',
#    },
#};
#sub complete_env_elem {
#    require Complete::Util;
#
#    my %args  = @_;
#    my $word  = $args{word} // "";
#    my $env   = $args{env};
#    my @elems;
#    if ($^O eq 'MSWin32') {
#        @elems = split /;/, ($ENV{$env} // '');
#    } else {
#        @elems = split /:/, ($ENV{$env} // '');
#    }
#    Complete::Util::complete_array_elem(
#        word=>$word, array=>\@elems,
#    );
#}
#
#$SPEC{complete_path_env_elem} = {
#    v => 1.1,
#    summary => 'Complete from elements of PATH environment variable',
#    description => <<'_',
#
#PATH environment variable contains colon- (or, on Windows, semicolon-) separated
#elements. This routine complete from those elements.
#
#_
#    args => {
#        word     => { schema=>[str=>{default=>''}], pos=>0, req=>1 },
#    },
#    result_naked => 1,
#    result => {
#        schema => 'array',
#    },
#};
#sub complete_path_env_elem {
#    my %args  = @_;
#    complete_env_elem(word => $args{word}, env => 'PATH');
#}
#
#1;
#
#__END__
#
### Complete/File.pm ###
#package Complete::File;
#
#our $DATE = '2016-10-20'; 
#our $VERSION = '0.42'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Complete::Common qw(:all);
#
#require Exporter;
#our @ISA = qw(Exporter);
#our @EXPORT_OK = qw(
#                       complete_file
#                       complete_dir
#               );
#
#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 => {
#        %arg_word,
#        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*']}],
#            tags => ['category:filtering'],
#        },
#        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*',
#            tags => ['category:filtering'],
#        },
#        exclude_dir => {
#            schema => 'bool*',
#            description => <<'_',
#
#This is also an alternative to specifying full `filter`. Set this to true if you
#do not want directories.
#
#If you only want directories, take a look at `complete_dir()`.
#
#_
#            tags => ['category:filtering'],
#        },
#        file_ext_filter => {
#            schema => ['any*', of=>['re*', ['array*',of=>'str*']]],
#            description => <<'_',
#
#This is also an alternative to specifying full `filter` or `file_regex_filter`.
#You can set this to a regex or a set of extensions to accept. Note that like in
#`file_regex_filter`, directories of any name is also still allowed.
#
#_
#            tags => ['category:filtering'],
#        },
#        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 Encode;
#    require File::Glob;
#
#    my %args   = @_;
#    my $word   = $args{word} // "";
#    my $handle_tilde = $args{handle_tilde} // 1;
#    my $allow_dot   = $args{allow_dot} // 1;
#
#    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 = Encode::decode('UTF-8', $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, Encode::decode('UTF-8', $_);
#        }
#        \@res;
#    };
#
#
#    my $filter;
#    if ($args{filter} && !ref($args{filter})) {
#        my @seqs = split /\s*\|\s*/, $args{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 ($args{filter} && ref($args{filter}) eq 'CODE') {
#        $filter = $args{filter};
#    }
#
#    my $filter_fregex;
#    if ($args{file_regex_filter}) {
#        $filter_fregex = sub {
#            my $name = shift;
#            return 1 if -d $name;
#            return 0 unless -f _;
#            return 1 if $name =~ $args{file_regex_filter};
#            0;
#        };
#    }
#
#    my $filter_fext;
#    if ($args{file_ext_filter} && ref $args{file_ext_filter} eq 'Regexp') {
#        $filter_fext = sub {
#            my $name = shift;
#            return 1 if -d $name;
#            return 0 unless -f _;
#            my $ext = $name =~ /\.(\w+)\z/ ? $1 : '';
#            return 1 if $ext =~ $args{file_ext_filter};
#            0;
#        };
#    } elsif ($args{file_ext_filter} && ref $args{file_ext_filter} eq 'ARRAY') {
#        $filter_fext = sub {
#            my $name = shift;
#            return 1 if -d $name;
#            return 0 unless -f _;
#            my $ext = $name =~ /\.(\w+)\z/ ? $1 : '';
#            if ($Complete::Common::OPT_CI) {
#                $ext = lc($ext);
#                for my $e (@{ $args{file_ext_filter} }) {
#                    return 1 if $ext eq lc($e);
#                }
#            } else {
#                for my $e (@{ $args{file_ext_filter} }) {
#                    return 1 if $ext eq $e;
#                }
#            }
#            0;
#        };
#    }
#
#    my $filter_dir;
#    if ($args{_dir}) {
#        $filter_dir = sub { return 0 unless (-d $_[0]); 1 };
#    }
#
#    my $filter_xdir;
#    if ($args{exclude_dir}) {
#        $filter_xdir = sub { return 0 if (-d $_[0]); 1 };
#    }
#
#    my $final_filter = sub {
#        my $name = shift;
#        if ($filter_dir)    { return 0 unless $filter_dir->($name)    }
#        if ($filter_xdir)   { return 0 unless $filter_xdir->($name)   }
#        if ($filter)        { return 0 unless $filter->($name)        }
#        if ($filter_fregex) { return 0 unless $filter_fregex->($name) }
#        if ($filter_fext)   { return 0 unless $filter_fext->($name)   }
#        1;
#    };
#
#    Complete::Path::complete_path(
#        word => $word,
#        list_func => $list,
#        is_dir_func => sub { -d $_[0] },
#        filter_func => $final_filter,
#        starting_path => $starting_path,
#        result_prefix => $result_prefix,
#    );
#}
#
#$SPEC{complete_dir} = do {
#    my $spec = {%{ $SPEC{complete_file} }}; 
#
#    $spec->{summary} = 'Complete directory from local filesystem '.
#        '(wrapper for complete_dir() that only picks directories)';
#    $spec->{args} = { %{$spec->{args}} }; 
#    delete $spec->{args}{file_regex_filter};
#    delete $spec->{args}{file_ext_filter};
#    delete $spec->{args}{exclude_dir};
#
#    $spec;
#};
#sub complete_dir {
#    my %args = @_;
#
#    complete_file(%args, _dir=>1);
#}
#
#1;
#
#__END__
#
### Complete/Fish.pm ###
#package Complete::Fish;
#
#our $DATE = '2016-10-21'; 
#our $VERSION = '0.05'; 
#
#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{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 = '2017-01-13'; 
#our $VERSION = '0.46'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#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;
#
#    if ($word =~ /\A\$/) {
#        {
#            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!) {
#        {
#            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(~[^/]*)/!) {
#        $fres = {words=>Complete::File::complete_file(word=>$word),
#                 path_sep=>'/'};
#        goto RETURN_RES;
#    }
#
#    require String::Wildcard::Bash;
#    if (String::Wildcard::Bash::contains_wildcard($word)) {
#        {
#            my $compres = [glob("$word*")];
#            last unless @$compres;
#            for (@$compres) {
#                $_ .= "/" if (-d $_);
#            }
#            $fres = {words=>$compres, path_sep=>'/'};
#            goto RETURN_RES;
#        }
#    }
#    $fres = {words=>Complete::File::complete_file(word=>$word),
#             path_sep=>'/'};
#  RETURN_RES:
#    $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 <pm: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 <pm: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 <pm: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 <pm: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 <pm: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 <pm: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;
#
#
#    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'";
#        next if $res->{is_arg};
#        $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-/) {
#
#          SHORT_OPTS:
#            {
#                last unless $opts{"-".substr($word,1,1)};
#
#                last unless $bundling;
#
#                my $j = $i;
#                my $rest = substr($word, 1);
#                my @inswords;
#                my $encounter_equal_sign;
#              EXPAND:
#                while (1) {
#                    $rest =~ s/(.)// or last;
#                    my $opt = "-$1";
#                    my $opthash = $opts{$opt};
#                    unless ($opthash) {
#                        @inswords = ();
#                        $expects[$i]{short_only} = 0;
#                        $rest = $word;
#                        last EXPAND;
#                    }
#                    if ($opthash->{parsed}{max_vals}) {
#                        _mark_seen(\%seen_opts, $opt, \%opts);
#
#                        if ($i == $j) {
#                            $words[$i] = $opt;
#                        } else {
#                            push @inswords, $opt;
#                            $j++;
#                        }
#
#                        my $expand;
#                        if (length $rest) {
#                            $expand++;
#                            $expects[$j > $i ? $j+1 : $j+2]{do_complete_optname} = 0;
#                            $expects[$j > $i ? $j+1 : $j+2]{optval} = $opt;
#                        } else {
#                            $expects[$j > $i ? $j-1 : $j]{optname} = $opt;
#                            $expects[$j > $i ? $j-1 : $j]{comp_result} = [
#                                substr($word, 0, length($word)-length($rest))];
#                        }
#
#                        if ($rest =~ s/\A=//) {
#                            $encounter_equal_sign++;
#                        }
#
#                        if ($expand) {
#                            push @inswords, "=", $rest;
#                            $j+=2;
#                        }
#                        last EXPAND;
#                    }
#                    _mark_seen(\%seen_opts, $opt, \%opts);
#                    if ($i == $j) {
#                        $words[$i] = $opt;
#                    } else {
#                        push @inswords, $opt;
#                    }
#                    $j++;
#                }
#
#
#                my $prefix = $encounter_equal_sign ? '' :
#                    substr($word, 0, length($word)-length($rest));
#                splice @words, $i+1, 0, @inswords;
#                for (0..@inswords) {
#                    $expects[$i+$_]{prefix} = $prefix;
#                    $expects[$i+$_]{word}   = $rest;
#                }
#                $cword += @inswords;
#                $i += @inswords;
#                $word = $words[$i];
#                $expects[$i]{short_only} //= 1;
#            } 
#
#          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 }
#                }
#
#                for (1 .. $min_vals) {
#                    $i++;
#                    last WORD if $i >= @words;
#                    $expects[$i]{optval} = $opt;
#                    $expects[$i]{nth} = $nth;
#                    push @{ $parsed_opts{$opt} }, $words[$i];
#                }
#                for (1 .. $max_vals-$min_vals) {
#                    last if $i+$_ >= @words;
#                    last if $words[$i+$_] =~ /\A-/; 
#                    $expects[$i+$_]{optval} = $opt; 
#                    $expects[$i]{nth} = $nth;
#                    push @{ $parsed_opts{$opt} }, $words[$i+$_];
#                }
#            } 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 if $word =~ /\A[^-]/;
#        last unless exists $exp->{optname};
#        last if defined($exp->{do_complete_optname}) &&
#            !$exp->{do_complete_optname};
#        if ($exp->{comp_result}) {
#            push @answers, $exp->{comp_result};
#            last;
#        }
#        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);
#        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) {
#            $compres = $comp->(%compargs);
#            Complete::Util::modify_answer(answer=>$compres, prefix=>$exp->{prefix})
#                if defined $exp->{prefix};
#        }
#        if (!$compres || !$comp) {
#            $compres = _default_completion(%compargs);
#            Complete::Util::modify_answer(answer=>$compres, prefix=>$exp->{prefix})
#                if defined $exp->{prefix};
#        }
#        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,
#        );
#        my $compres = $comp->(%compargs) if $comp;
#        if (!defined $compres) {
#            $compres = _default_completion(%compargs);
#        }
#        push @answers, $compres;
#    }
#
#    $fres = Complete::Util::combine_answers(@answers) // [];
#
#  RETURN_RES:
#    $fres;
#}
#
#1;
#
#__END__
#
### Complete/Path.pm ###
#package Complete::Path;
#
#our $DATE = '2016-06-17'; 
#our $VERSION = '0.23'; 
#
#use 5.010001;
#use strict;
#use warnings;
#use Log::Any::IfLOG '$log';
#
#use Complete::Common qw(:all);
#
#our $COMPLETE_PATH_TRACE = $ENV{COMPLETE_PATH_TRACE} // 0;
#
#require Exporter;
#our @ISA = qw(Exporter);
#our @EXPORT_OK = qw(
#                       complete_path
#               );
#
#sub _dig_leaf {
#    my ($p, $list_func, $is_dir_func, $filter_func, $path_sep) = @_;
#    my $num_dirs;
#    my $listres = $list_func->($p, '', 0);
#    return $p unless ref($listres) eq 'ARRAY' && @$listres;
#    my @candidates;
#  L1:
#    for my $e (@$listres) {
#        my $p2 = $p =~ m!\Q$path_sep\E\z! ? "$p$e" : "$p$path_sep$e";
#        {
#            local $_ = $p2; 
#            next L1 if $filter_func && !$filter_func->($p2);
#        }
#        push @candidates, $p2;
#    }
#    return $p unless @candidates == 1;
#    my $p2 = $candidates[0];
#    my $is_dir;
#    if ($p2 =~ 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, $filter_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 => {
#        %arg_word,
#        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 => '/',
#        },
#    },
#    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 $result_prefix = $args{result_prefix};
#    my $starting_path = $args{starting_path} // '';
#
#    my $ci          = $Complete::Common::OPT_CI;
#    my $word_mode   = $Complete::Common::OPT_WORD_MODE;
#    my $fuzzy       = $Complete::Common::OPT_FUZZY;
#    my $map_case    = $Complete::Common::OPT_MAP_CASE;
#    my $exp_im_path = $Complete::Common::OPT_EXP_IM_PATH;
#    my $dig_leaf    = $Complete::Common::OPT_DIG_LEAF;
#
#    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,
#            );
#            my $exact_matches = [grep {
#                $_ eq $intdir || $_ eq $intdir_with_path_sep
#            } @$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,
#        );
#
#      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) {
#                {
#                    my $p2 = _dig_leaf($p, $list_func, $is_dir_func, $filter_func, $path_sep);
#                    last if $p2 eq $p;
#                    $p = $p2;
#
#                    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/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 = '2016-12-10'; 
#our $VERSION = '0.58'; 
#
#use 5.010001;
#use strict;
#use warnings;
#use Log::Any::IfLOG '$log';
#
#use Complete::Common qw(:all);
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(
#                       hashify_answer
#                       arrayify_answer
#                       combine_answers
#                       modify_answer
#                       complete_array_elem
#                       complete_hash_key
#                       complete_comma_sep
#               );
#
#our %SPEC;
#
#our $COMPLETE_UTIL_TRACE = $ENV{COMPLETE_UTIL_TRACE} // 0;
#
#$SPEC{':package'} = {
#    v => 1.1,
#    summary => 'General completion routine',
#    description => <<'_',
#
#This package provides some generic completion routine that follows the
#<pm:Complete> convention (if you are looking for bash/shell tab completion
#routine, take a look at the See Also section). The main routine is
#`complete_array_elem` which tries to complete a word using choices from elements
#of supplied array. For example:
#
#    complete_array_elem(word => "a", array => ["apple", "apricot", "banana"]);
#
#The routine will first try a simple substring prefix matching. If that fails,
#will try some other methods like word-mode, character-mode, or fuzzy matching.
#These methods can be disabled using settings.
#
#There are other utility routines e.g. for converting completion answer structure
#from hash to array/array to hash, combine or modify answer, etc. These routines
#are usually used by the other more specific or higher-level completion modules.
#
#_
#};
#
#$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,
#        },
#    },
#    args_as => 'array',
#    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,
#        },
#    },
#    args_as => 'array',
#    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;
#}
#
#our $code_editdist;
#our $editdist_flex;
#
#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];
#}
#
#my %complete_array_elem_args = (
#    %arg_word,
#    array       => {
#        schema => ['array*'=>{of=>'str*'}],
#        req => 1,
#        pos => 1,
#        greedy => 1,
#    },
#    exclude     => {
#        schema => ['array*'],
#    },
#    replace_map => {
#        schema => ['hash*', each_value=>['array*', of=>'str*']],
#        description => <<'_',
#
#You can supply correction entries in this option. An example is when array if
#`['mount','unmount']` and `umount` is a popular "typo" for `unmount`. When
#someone already types `um` it cannot be completed into anything (even the
#current fuzzy mode will return *both* so it cannot complete immediately).
#
#One solution is to add replace_map `{'unmount'=>['umount']}`. This way, `umount`
#will be regarded the same as `unmount` and when user types `um` it can be
#completed unambiguously into `unmount`.
#
#_
#        tags => ['experimental'],
#    },
#);
#
#$SPEC{complete_array_elem} = {
#    v => 1.1,
#    summary => 'Complete from array',
#    description => <<'_',
#
#Try to find completion from an array of strings. Will attempt several methods,
#from the cheapest and most discriminating to the most expensive and least
#discriminating: normal string prefix matching, word-mode matching (see
#`Complete::Common::OPT_WORD_MODE` for more details), char-mode matching (see
#`Complete::Common::OPT_CHAR_MODE` for more details), and fuzzy matching (see
#`Complete::Common::OPT_FUZZY` for more details).
#
#Will sort the resulting completion list, so you don't have to presort the array.
#
#_
#    args => {
#        %complete_array_elem_args,
#    },
#    result_naked => 1,
#    result => {
#        schema => 'array',
#    },
#};
#sub complete_array_elem {
#    my %args  = @_;
#
#    my $array0    = $args{array} or die "Please specify array";
#    my $word      = $args{word} // "";
#
#    my $ci          = $Complete::Common::OPT_CI;
#    my $map_case    = $Complete::Common::OPT_MAP_CASE;
#    my $word_mode   = $Complete::Common::OPT_WORD_MODE;
#    my $char_mode   = $Complete::Common::OPT_CHAR_MODE;
#    my $fuzzy       = $Complete::Common::OPT_FUZZY;
#
#    $log->tracef("[computil] entering complete_array_elem(), word=<%s>", $word)
#        if $COMPLETE_UTIL_TRACE;
#
#    my $res;
#
#    unless (@$array0) {
#        $res = []; goto RETURN_RES;
#    }
#
#    my $wordn = $ci ? uc($word) : $word; $wordn =~ s/_/-/g if $map_case;
#
#    my $excluden;
#    if ($args{exclude}) {
#        $excluden = {};
#        for my $el (@{$args{exclude}}) {
#            my $eln = $ci ? uc($el) : $el; $eln =~ s/_/-/g if $map_case;
#            $excluden->{$eln} //= 1;
#        }
#    }
#
#    my $rmapn;
#    my $rev_rmapn; 
#    if (my $rmap = $args{replace_map}) {
#        $rmapn = {};
#        $rev_rmapn = {};
#        for my $k (keys %$rmap) {
#            my $kn = $ci ? uc($k) : $k; $kn =~ s/_/-/g if $map_case;
#            my @vn;
#            for my $v (@{ $rmap->{$k} }) {
#                my $vn = $ci ? uc($v) : $v; $vn =~ s/_/-/g if $map_case;
#                push @vn, $vn;
#                $rev_rmapn->{$vn} //= $k;
#            }
#            $rmapn->{$kn} = \@vn;
#        }
#    }
#
#    my @words; 
#    my @array ;  
#    my @arrayn;  
#
#    $log->tracef("[computil] Trying normal string-prefix matching ...") if $COMPLETE_UTIL_TRACE;
#    for my $el (@$array0) {
#        my $eln = $ci ? uc($el) : $el; $eln =~ s/_/-/g if $map_case;
#        next if $excluden && $excluden->{$eln};
#        push @array , $el;
#        push @arrayn, $eln;
#        push @words , $el if 0==index($eln, $wordn);
#        if ($rmapn && $rmapn->{$eln}) {
#            for my $vn (@{ $rmapn->{$eln} }) {
#                push @array , $el;
#                push @arrayn, $vn;
#                push @words , $vn if 0==index($vn, $wordn);
#            }
#        }
#    }
#    $log->tracef("[computil] Result from normal string-prefix matching: %s", \@words) if @words && $COMPLETE_UTIL_TRACE;
#
#    {
#        last unless $word_mode && !@words;
#        my @split_wordn = $wordn =~ /(\w+)/g;
#        unshift @split_wordn, '' if $wordn =~ /\A\W/;
#        last unless @split_wordn > 1;
#        my $re = '\A';
#        for my $i (0..$#split_wordn) {
#            $re .= '(?:\W+\w+)*\W+' if $i;
#            $re .= quotemeta($split_wordn[$i]).'\w*';
#        }
#        $re = qr/$re/;
#        $log->tracef("[computil] Trying word-mode matching (re=%s) ...", $re) if $COMPLETE_UTIL_TRACE;
#
#        for my $i (0..$#array) {
#            my $match;
#            {
#                if ($arrayn[$i] =~ $re) {
#                    $match++;
#                    last;
#                }
#                my $tmp = $array[$i];
#                if ($tmp =~ s/([a-z0-9_])([A-Z])/$1-$2/g) {
#                    $tmp = uc($tmp) if $ci; $tmp =~ s/_/-/g if $map_case; 
#                    if ($tmp =~ $re) {
#                        $match++;
#                        last;
#                    }
#                }
#            }
#            next unless $match;
#            push @words, $array[$i];
#        }
#        $log->tracef("[computil] Result from word-mode matching: %s", \@words) if @words && $COMPLETE_UTIL_TRACE;
#    }
#
#    if ($char_mode && !@words && length($wordn) && length($wordn) <= 7) {
#        my $re = join(".*", map {quotemeta} split(//, $wordn));
#        $re = qr/$re/;
#        $log->tracef("[computil] Trying char-mode matching (re=%s) ...", $re) if $COMPLETE_UTIL_TRACE;
#        for my $i (0..$#array) {
#            push @words, $array[$i] if $arrayn[$i] =~ $re;
#        }
#        $log->tracef("[computil] Result from char-mode matching: %s", \@words) if @words && $COMPLETE_UTIL_TRACE;
#    }
#
#    if ($fuzzy && !@words) {
#        $log->tracef("[computil] Trying fuzzy matching ...") if $COMPLETE_UTIL_TRACE;
#        $code_editdist //= do {
#            my $env = $ENV{COMPLETE_UTIL_LEVENSHTEIN} // '';
#            if ($env eq 'xs') {
#                require Text::Levenshtein::XS;
#                $editdist_flex = 0;
#                \&Text::Levenshtein::XS::distance;
#            } elsif ($env eq 'flexible') {
#                require Text::Levenshtein::Flexible;
#                $editdist_flex = 1;
#                \&Text::Levenshtein::Flexible::levenshtein_l;
#            } elsif ($env eq 'pp') {
#                $editdist_flex = 0;
#                \&__editdist;
#            } elsif (eval { require Text::Levenshtein::Flexible; 1 }) {
#                $editdist_flex = 1;
#                \&Text::Levenshtein::Flexible::levenshtein_l;
#            } else {
#                $editdist_flex = 0;
#                \&__editdist;
#            }
#        };
#
#        my $factor = 1.3;
#        my $x = -1;
#        my $y = 1;
#
#
#        my %editdists;
#      ELEM:
#        for my $i (0..$#array) {
#            my $eln = $arrayn[$i];
#
#            for my $l (length($wordn)-$y .. length($wordn)+$y) {
#                next if $l <= 0;
#                my $chopped = substr($eln, 0, $l);
#                my $maxd = __min(
#                    __min(length($chopped), length($word))/$factor,
#                    $fuzzy,
#                );
#                my $d;
#                unless (defined $editdists{$chopped}) {
#                    if ($editdist_flex) {
#                        $d = $code_editdist->($wordn, $chopped, $maxd);
#                        next ELEM unless defined $d;
#                    } else {
#                        $d = $code_editdist->($wordn, $chopped);
#                    }
#                    $editdists{$chopped} = $d;
#                } else {
#                    $d = $editdists{$chopped};
#                }
#                next unless $d <= $maxd;
#                push @words, $array[$i];
#                next ELEM;
#            }
#        }
#        $log->tracef("[computil] Result from fuzzy matching: %s", \@words) if @words && $COMPLETE_UTIL_TRACE;
#    }
#
#    if ($rmapn && @words) {
#        my @wordsn;
#        for my $el (@words) {
#            my $eln = $ci ? uc($el) : $el; $eln =~ s/_/-/g if $map_case;
#            push @wordsn, $eln;
#        }
#        for my $i (0..$#words) {
#            if (my $w = $rev_rmapn->{$wordsn[$i]}) {
#                $words[$i] = $w;
#            }
#        }
#    }
#
#    $res =$ci ? [sort {lc($a) cmp lc($b)} @words] : [sort @words];
#
#  RETURN_RES:
#    $log->tracef("[computil] leaving complete_array_elem(), res=%s", $res)
#        if $COMPLETE_UTIL_TRACE;
#    $res;
#}
#
#$SPEC{complete_hash_key} = {
#    v => 1.1,
#    summary => 'Complete from hash keys',
#    args => {
#        %arg_word,
#        hash      => { schema=>['hash*'=>{}], req=>1 },
#    },
#    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} // "";
#
#    complete_array_elem(
#        word=>$word, array=>[sort keys %$hash],
#    );
#}
#
#my %complete_comma_sep_args = (
#    %complete_array_elem_args,
#    sep => {
#        schema  => 'str*',
#        default => ',',
#    },
#    uniq => {
#        summary => 'Whether list should contain unique elements',
#        description => <<'_',
#
#When this option is set to true, if the formed list in the current word already
#contains an element, the element will not be offered again as completion answer.
#For example, if `elems` is `[1,2,3,4]` and `word` is `2,3,` then without `uniq`
#set to true the completion answer is:
#
#    2,3,1
#    2,3,2
#    2,3,3
#    2,3,4
#
#but with `uniq` set to true, the completion answer becomes:
#
#    2,3,1
#    2,3,4
#
#See also the `remaining` option for a more general mechanism of offering fewer
#elements.
#
#_
#        schema => ['bool*', is=>1],
#    },
#    remaining => {
#        schema => ['code*'],
#        summary => 'What elements should remain for completion',
#        description => <<'_',
#
#This is a more general mechanism if the `uniq` option does not suffice. Suppose
#you are offering completion for sorting fields. The elements are field names as
#well as field names prefixed with dash (`-`) to mean sorting with a reverse
#order. So for example `elems` is `["name","-name","age","-age"]`. When current
#word is `name`, it doesn't make sense to offer `name` nor `-name` again as the
#next sorting field. So we can set `remaining` to this code:
#
#    sub {
#        my ($seen_elems, $elems) = @_;
#
#        my %seen;
#        for (@$seen_elems) {
#            (my $nodash = $_) =~ s/^-//;
#            $seen{$nodash}++;
#        }
#
#        my @remaining;
#        for (@$elems) {
#            (my $nodash = $_) =~ s/^-//;
#            push @remaining, $_ unless $seen{$nodash};
#        }
#
#        \@remaining;
#    }
#
#As you can see above, the code is given `$seen_elems` and `$elems` as arguments
#and is expected to return remaining elements to offer.
#
#_
#        tags => ['hidden-cli'],
#    },
#);
#$complete_comma_sep_args{elems} = delete $complete_comma_sep_args{array};
#
#$SPEC{complete_comma_sep} = {
#    v => 1.1,
#    summary => 'Complete a comma-separated list string',
#    args => {
#        %complete_comma_sep_args,
#    },
#    result_naked => 1,
#    result => {
#        schema => 'array',
#    },
#};
#sub complete_comma_sep {
#    my %args  = @_;
#    my $word      = delete $args{word} // "";
#    my $sep       = delete $args{sep} // ',';
#    my $elems     = delete $args{elems} or die "Please specify elems";
#    my $uniq      = delete $args{uniq};
#    my $remaining = delete $args{remaining};
#
#    my $ci = $Complete::Common::OPT_CI;
#
#    my @mentioned_elems = split /\Q$sep\E/, $word, -1;
#    my $cae_word = @mentioned_elems ? pop(@mentioned_elems) : '';
#
#    my $remaining_elems;
#    if ($remaining) {
#        $remaining_elems = $remaining->(\@mentioned_elems, $elems);
#    } elsif ($uniq) {
#        my %mem;
#        $remaining_elems = [];
#        for (@mentioned_elems) {
#            if ($ci) { $mem{lc $_}++ } else { $mem{$_}++ }
#        }
#        for (@$elems) {
#            push @$remaining_elems, $_ unless ($ci ? $mem{lc $_} : $mem{$_});
#        }
#    } else {
#        $remaining_elems = $elems;
#    }
#
#    my $cae_res = complete_array_elem(
#        %args,
#        word  => $cae_word,
#        array => $remaining_elems,
#    );
#
#    my $prefix = join($sep, @mentioned_elems);
#    $prefix .= $sep if @mentioned_elems;
#    $cae_res = [map { "$prefix$_" } @$cae_res];
#
#    {
#        last unless @$cae_res == 1;
#        last if @$remaining_elems <= 1;
#        $cae_res->[0] .= $sep;
#    }
#    $cae_res;
#}
#
#$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 <prog: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),
#        complete_module(word=>$word),
#    );
#
#But 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};
#}
#
#$SPEC{modify_answer} = {
#    v => 1.1,
#    summary => 'Modify answer (add prefix/suffix, etc)',
#    args => {
#        answer => {
#            schema => ['any*', of=>['hash*','array*']], 
#            req => 1,
#            pos => 0,
#        },
#        suffix => {
#            schema => 'str*',
#        },
#        prefix => {
#            schema => 'str*',
#        },
#    },
#    result_naked => 1,
#    result => {
#        schema => 'undef',
#    },
#};
#sub modify_answer {
#    my %args = @_;
#
#    my $answer = $args{answer};
#    my $words = ref($answer) eq 'HASH' ? $answer->{words} : $answer;
#
#    if (defined(my $prefix = $args{prefix})) {
#        $_ = "$prefix$_" for @$words;
#    }
#    if (defined(my $suffix = $args{suffix})) {
#        $_ = "$_$suffix" for @$words;
#    }
#    undef;
#}
#
#1;
#
#__END__
#
### Complete/Zsh.pm ###
#package Complete::Zsh;
#
#our $DATE = '2016-10-22'; 
#our $VERSION = '0.03'; 
#
#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{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 = '2017-01-16'; 
#our $VERSION = '0.32'; 
#
#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_tilde}    //= 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 {
#    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);
#
#        my $res = [
#            "!$enc", 
#            $ws1, 
#            $1, 
#            $2, 
#            $3, 
#            $4, 
#        ] if $needs_res;
#
#        $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 grep {$_ eq $enc} @{$self->{allow_encodings}};
#        }
#        if ($self->{disallow_encodings}) {
#            return ("Encoding '$enc' is in ".
#                        "disallow_encodings list")
#                if grep {$_ eq $enc} @{$self->{disallow_encodings}};
#        }
#
#        if ($enc eq 'json') {
#
#            $val =~ /\A
#                     (".*"|\[.*\]|\{.*\}|\S+)
#                     (\s*)
#                     (?: ([;#])(.*) )?
#                     \z/x or return ("Invalid syntax in JSON-encoded value");
#            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 'path' || $enc eq 'paths') {
#
#            my $decode_res = $self->_decode_path_or_paths($val, $enc);
#            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 $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 $decode_res = $self->_decode_base64($1);
#            return ($decode_res->[1]) unless $decode_res->[0] == 200;
#            return (undef, $res, $decode_res->[2]);
#
#        } elsif ($enc eq 'none') {
#
#            return (undef, $res, $val);
#
#        } 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 $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]);
#
#    } elsif ($val =~ /\A~/ && $self->{enable_tilde}) {
#
#        $val =~ /\A
#                 ~(.*)
#                 (\s*)
#                 (?: ([;#])(.*) )?
#                 \z/x or return ("Invalid syntax in path value");
#        my $res = [
#            '~', 
#            '', 
#            $1, 
#            $2, 
#            $3, 
#            $4, 
#        ] if $needs_res;
#
#        my $decode_res = $self->_decode_path_or_paths($val, 'path');
#        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 _get_my_user_name {
#    if ($^O eq 'MSWin32') {
#        return $ENV{USERNAME};
#    } else {
#        return $ENV{USER} if $ENV{USER};
#        my @pw;
#        eval { @pw = getpwuid($>) };
#        return $pw[0] if @pw;
#    }
#}
#
#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;
#        eval { @pw = getpwuid($>) };
#        return $pw[7] if @pw;
#    }
#
#    die "Can't get home directory";
#}
#
#sub _get_users_home_dir {
#    my ($name) = @_;
#
#    if ($^O eq 'MSWin32') {
#        return undef;
#    } else {
#        if ($name eq getpwuid($<)) {
#            return _get_my_home_dir();
#        }
#
#      SCOPE: {
#            my $home = (getpwnam($name))[7];
#            return $home if $home and -d $home;
#        }
#
#        return undef;
#    }
#
#}
#
#sub _decode_json {
#    my ($self, $val) = @_;
#    state $json = do {
#        if (eval { require Cpanel::JSON::XS; 1 }) {
#            Cpanel::JSON::XS->new->allow_nonref;
#        } else {
#            require JSON::PP;
#            JSON::PP->new->allow_nonref;
#        }
#    };
#    my $res;
#    eval { $res = $json->decode($val) };
#    if ($@) {
#        return [500, "Invalid JSON: $@"];
#    } else {
#        return [200, "OK", $res];
#    }
#}
#
#sub _decode_path_or_paths {
#    my ($self, $val, $which) = @_;
#
#    if ($val =~ m!\A~([^/]+)?(?:/|\z)!) {
#        my $home_dir = length($1) ?
#            _get_users_home_dir($1) : _get_my_home_dir();
#        unless ($home_dir) {
#            if (length $1) {
#                return [500, "Can't get home directory for user '$1' in path"];
#            } else {
#                return [500, "Can't get home directory for current user in path"];
#            }
#        }
#        $val =~ s!\A~([^/]+)?!$home_dir!;
#    }
#    $val =~ s!(?<=.)/\z!!;
#
#    if ($which eq 'path') {
#        return [200, "OK", $val];
#    } else {
#        return [200, "OK", [glob $val]];
#    }
#}
#
#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 scalar <$fh>;
#}
#
#sub read_file {
#    my $self = shift;
#    my $filename = shift;
#    $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 = shift;
#    $self->_init_read;
#    $self->_read_string(@_);
#}
#
#1;
#
#__END__
#
### Config/IOD/Expr.pm ###
#package Config::IOD::Expr;
#
#our $DATE = '2017-01-16'; 
#our $VERSION = '0.32'; 
#
#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 = '2017-01-16'; 
#our $VERSION = '0.32'; 
#
#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, $cb) = @_;
#
#    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 $_raw_val; 
#
#    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 ($cb) {
#                $cb->(
#                    event => 'directive',
#                    linum=>$self->{_linum}, line=>$line, cur_section=>$self->{_cur_section},
#                    directive => $directive,
#                    args => $args,
#                );
#            }
#
#            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, $cb));
#                $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*[;#]/) {
#
#            if ($cb) {
#                $cb->(
#                    event => 'comment',
#                    linum=>$self->{_linum}, line=>$line, cur_section=>$self->{_cur_section},
#                );
#            }
#
#            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);
#            }
#
#            if ($cb) {
#                $cb->(
#                    event => 'section',
#                    linum=>$self->{_linum}, line=>$line, cur_section=>$self->{_cur_section},
#                    section => $cur_section,
#                );
#            }
#
#            next LINE;
#        }
#
#        if ($line =~ /^\s*([^=]+?)\s*=\s*(.*)/) {
#            my $key = $1;
#            my $val = $2;
#
#            if ($val =~ /\A["!\\[\{~]/) {
#                $_raw_val = $val if $cb;
#                my ($err, $parse_res, $decoded_val) = $self->_parse_raw_value($val);
#                $self->_err("Invalid value: " . $err) if $err;
#                $val = $decoded_val;
#            } else {
#                $_raw_val = $val if $cb;
#                $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;
#            }
#
#            if ($cb) {
#                $cb->(
#                    event => 'key',
#                    linum=>$self->{_linum}, line=>$line, cur_section=>$self->{_cur_section},
#                    key => $key,
#                    val => $val,
#                    raw_val => $_raw_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.pm ###
#package Data::Clean;
#
#our $DATE = '2017-01-14'; 
#our $VERSION = '0.48'; 
#
#use 5.010001;
#use strict;
#use warnings;
#use Log::Any::IfLOG '$log';
#
#sub new {
#    my ($class, %opts) = @_;
#    my $self = bless {_opts=>\%opts}, $class;
#    $log->tracef("Cleanser options: %s", \%opts);
#
#    my $cd = $self->_generate_cleanser_code;
#    for my $mod (keys %{ $cd->{modules} }) {
#        (my $mod_pm = "$mod.pm") =~ s!::!/!g;
#        require $mod_pm;
#    }
#    $self->{_cd} = $cd;
#    $self->{_code} = eval $cd->{src};
#    {
#        last unless $cd->{clone_func} =~ /(.+)::(.+)/;
#        (my $mod_pm = "$1.pm") =~ s!::!/!g;
#        require $mod_pm;
#    }
#    die "Can't generate code: $@" if $@;
#
#    $self;
#}
#
#sub command_call_method {
#    my ($self, $cd, $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, $cd, $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, $cd, $args) = @_;
#    return "{{var}} = {{var}} ? 1:0; \$ref = ''";
#}
#
#sub command_deref_scalar {
#    my ($self, $cd, $args) = @_;
#    return '{{var}} = ${ {{var}} }; $ref = ref({{var}})';
#}
#
#sub command_stringify {
#    my ($self, $cd, $args) = @_;
#    return '{{var}} = "{{var}}"; $ref = ""';
#}
#
#sub command_replace_with_ref {
#    my ($self, $cd, $args) = @_;
#    return '{{var}} = $ref; $ref = ""';
#}
#
#sub command_replace_with_str {
#    require String::PerlQuote;
#
#    my ($self, $cd, $args) = @_;
#    return "{{var}} = ".String::PerlQuote::double_quote($args->[0]).'; $ref=""';
#}
#
#sub command_unbless {
#    my ($self, $cd, $args) = @_;
#
#    return join(
#        "",
#        'my $reftype = Scalar::Util::reftype({{var}}); ',
#        '{{var}} = $reftype eq "HASH" ? {%{ {{var}} }} :',
#        ' $reftype eq "ARRAY" ? [@{ {{var}} }] :',
#        ' $reftype eq "SCALAR" ? \(my $copy = ${ {{var}} }) :',
#        ' $reftype eq "CODE" ? sub { goto &{ {{var}} } } :',
#        '(die "Cannot unbless object with type $ref")',
#    );
#}
#
#sub command_clone {
#    my ($self, $cd, $args) = @_;
#
#    my $limit = $args->[0] // 1;
#    return join(
#        "",
#        "if (++\$ctr_circ <= $limit) { ",
#        "{{var}} = $cd->{clone_func}({{var}}); redo ",
#        "} else { ",
#        "{{var}} = 'CIRCULAR'; \$ref = '' }",
#    );
#}
#
#sub command_die {
#    my ($self, $cd, $args) = @_;
#    return "die";
#}
#
#sub _generate_cleanser_code {
#    my $self = shift;
#    my $opts = $self->{_opts};
#
#    my $cd = {
#        modules => {}, 
#        clone_func   => $self->{_opts}{'!clone_func'},
#        code => '',
#    };
#
#    $cd->{modules}{'Scalar::Util'} //= 0;
#
#    if (!$cd->{clone_func}) {
#        if (eval { require Data::Clone; 1 }) {
#            $cd->{clone_func} = 'Data::Clone::clone';
#        } else {
#            $cd->{clone_func} = 'Clone::PP::clone';
#        }
#    }
#    {
#        last unless $cd->{clone_func} =~ /(.+)::(.+)/;
#        $cd->{modules}{$1} //= 0;
#    }
#
#    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);
#    };
#
#    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($cd, \@args);
#        $add_new_if->('$ref && $refs{ {{var}} }++', $act);
#    }
#
#    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($cd, \@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($cd, \@args));
#    }
#
#    if ($opts->{'!recurse_obj'}) {
#        $add_stmt->('stmt', 'my $reftype=Scalar::Util::reftype({{var}})//""');
#        $add_new_if->('$reftype eq "ARRAY"', '$process_array->({{var}})');
#        $add_if->('$reftype eq "HASH"' , '$process_hash->({{var}})');
#    } else {
#        $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($cd, \@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);
#    }
#
#    $cd->{src} = $code;
#
#    $cd;
#}
#
#sub clean_in_place {
#    my ($self, $data) = @_;
#
#    $self->{_code}->($data);
#}
#
#sub clone_and_clean {
#    no strict 'refs';
#
#    my ($self, $data) = @_;
#    my $clone = &{$self->{_cd}{clone_func}}($data);
#    $self->clean_in_place($clone);
#}
#
#1;
#
#__END__
#
### Data/Clean/FromJSON.pm ###
#package Data::Clean::FromJSON;
#
#our $DATE = '2017-01-15'; 
#our $VERSION = '0.38'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use parent qw(Data::Clean);
#
#sub new {
#    my ($class, %opts) = @_;
#    $opts{"JSON::PP::Boolean"} //= ['one_or_zero'];
#
#    $opts{"JSON::XS::Boolean"} //= ['one_or_zero'];
#
#    $opts{"Cpanel::JSON::XS::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 = '2017-01-15'; 
#our $VERSION = '0.38'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use parent qw(Data::Clean);
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(
#                       clean_json_in_place
#                       clone_and_clean_json
#               );
#
#sub new {
#    my ($class, %opts) = @_;
#    $opts{DateTime}  //= [call_method => 'epoch'];
#    $opts{'Time::Moment'} //= [call_method => 'epoch'];
#    $opts{'Math::BigInt'} //= [call_method => 'bstr'];
#    $opts{Regexp}    //= ['stringify'];
#    $opts{version}   //= ['stringify'];
#
#    $opts{SCALAR}    //= ['deref_scalar'];
#    $opts{-ref}      //= ['replace_with_ref'];
#    $opts{-circular} //= ['clone'];
#    $opts{-obj}      //= ['unbless'];
#
#    $opts{'!recurse_obj'} //= 1;
#    $class->SUPER::new(%opts);
#}
#
#sub get_cleanser {
#    my $class = shift;
#    state $singleton = $class->new;
#    $singleton;
#}
#
#sub clean_json_in_place {
#    __PACKAGE__->get_cleanser->clean_in_place(@_);
#}
#
#sub clone_and_clean_json {
#    __PACKAGE__->get_cleanser->clone_and_clean(@_);
#}
#
#1;
#
#__END__
#
### Data/Dmp.pm ###
#package Data::Dmp;
#
#our $DATE = '2017-01-30'; 
#our $VERSION = '0.23'; 
#
#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";
#our $OPT_REMOVE_PRAGMAS = 0;
#our $OPT_DEPARSE = 1;
#our $OPT_STRINGIFY_NUMBERS = 0;
#
#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_code {
#    my $code = shift;
#
#    state $deparse = do {
#        require B::Deparse;
#        B::Deparse->new("-l"); 
#    };
#
#    my $res = $deparse->coderef2text($code);
#
#    my ($res_before_first_line, $res_after_first_line) =
#        $res =~ /(.+?)^(#line .+)/ms;
#
#    if ($OPT_REMOVE_PRAGMAS) {
#        $res_before_first_line = "{";
#    } elsif ($OPT_PERL_VERSION < 5.016) {
#        $res_before_first_line =~ s/no feature ':all';/no feature;/m;
#    }
#    $res_after_first_line =~ s/^#line .+//gm;
#
#    $res = "sub" . $res_before_first_line . $res_after_first_line;
#    $res =~ s/^\s+//gm;
#    $res =~ s/\n+//g;
#    $res =~ s/;\}\z/}/;
#    $res;
#}
#
#sub _quote_key {
#    $_[0] =~ /\A-?[A-Za-z_][A-Za-z0-9_]*\z/ ||
#        $_[0] =~ /\A-?[1-9][0-9]{0,8}\z/ ? $_[0] : _double_quote($_[0]);
#}
#
#sub _dump {
#    my ($val, $subscript) = @_;
#
#    my $ref = ref($val);
#    if ($ref eq '') {
#        if (!defined($val)) {
#            return "undef";
#        } elsif (looks_like_number($val) && !$OPT_STRINGIFY_NUMBERS &&
#                     $val eq $val+0 &&
#                     $val !~ /\A-?(?:inf(?:inity)?|nan)\z/i
#                 ) {
#            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 = _quote_key($_);
#            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') {
#        $res = $OPT_DEPARSE ? _dump_code($val) : 'sub{"DUMMY"}';
#    } 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 wantarray() || @_ > 1 ? @_ : $_[0];
#    } 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.12'; 
#
#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::MaybeXS;
#            $json = JSON::MaybeXS->new->utf8->allow_nonref;
#        }
#        $json->encode($data);
#    }
#}
#
#1;
#
#__END__
#
### Data/Format/Pretty/Console.pm ###
#package Data::Format::Pretty::Console;
#
#our $DATE = '2016-03-13'; 
#our $VERSION = '0.37'; 
#
#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::MaybeXS;
#
#my $json = JSON::MaybeXS->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;
#
#our $DATE = '2016-03-11'; 
#our $VERSION = '0.12'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#require Exporter;
#our @ISA = qw(Exporter);
#our @EXPORT_OK = qw(format_pretty);
#
#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::MaybeXS;
#            $json = JSON::MaybeXS->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.37'; 
#
#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.37'; 
#
#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 = '2016-07-22'; 
#our $VERSION = '0.35'; 
#
#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 _in($$) {
#    state $load_dmp = do { require Data::Dmp };
#    my ($self, $needle, $haystack) = @_;
#    return 0 unless defined($needle);
#    my $r1 = ref($needle);
#    my $f1 = $r1 ? Data::Dmp::dmp($needle) : undef;
#    for (@$haystack) {
#        my $r2 = ref($_);
#        next if $r1 xor $r2;
#        return 1 if  $r2 && $f1 eq Data::Dmp::dmp($_);
#        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 = '2016-07-22'; 
#our $VERSION = '0.35'; 
#
#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 = '2016-07-22'; 
#our $VERSION = '0.35'; 
#
#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 = '2016-07-22'; 
#our $VERSION = '0.35'; 
#
#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 = '2016-07-22'; 
#our $VERSION = '0.35'; 
#
#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 = '2016-07-22'; 
#our $VERSION = '0.35'; 
#
#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 = '2016-07-22'; 
#our $VERSION = '0.35'; 
#
#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 = '2016-07-22'; 
#our $VERSION = '0.35'; 
#
#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 = '2016-07-22'; 
#our $VERSION = '0.35'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 _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 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/Coerce.pm ###
#package Data::Sah::Coerce;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#use Log::Any::IfLOG '$log';
#
#use Data::Sah::CoerceCommon;
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(gen_coercer);
#
#our %SPEC;
#
#our $Log_Coercer_Code = $ENV{LOG_SAH_COERCER_CODE} // 0;
#
#$SPEC{gen_coercer} = {
#    v => 1.1,
#    summary => 'Generate coercer code',
#    description => <<'_',
#
#This is mostly for testing. Normally the coercion rules will be used from
#<pm:Data::Sah>.
#
#_
#    args => {
#        %Data::Sah::CoerceCommon::gen_coercer_args,
#    },
#    result_naked => 1,
#};
#sub gen_coercer {
#    my %args = @_;
#
#    my $rt = $args{return_type} // 'val';
#    my $rt_sv = $rt eq 'str+val';
#
#    my $rules = Data::Sah::CoerceCommon::get_coerce_rules(
#        %args,
#        compiler=>'perl',
#        data_term=>'$data',
#    );
#
#    my $code;
#    if (@$rules) {
#        my $code_require = '';
#        my %mem;
#        for my $rule (@$rules) {
#            next unless $rule->{modules};
#            for my $mod (keys %{$rule->{modules}}) {
#                next if $mem{$mod}++;
#                $code_require .= "require $mod;\n";
#            }
#        }
#
#        my $expr;
#        for my $i (reverse 0..$#{$rules}) {
#            my $rule = $rules->[$i];
#            if ($i == $#{$rules}) {
#                if ($rt_sv) {
#                    $expr = "($rule->{expr_match}) ? ['$rule->{name}', $rule->{expr_coerce}] : [undef, \$data]";
#                } else {
#                    $expr = "($rule->{expr_match}) ? ($rule->{expr_coerce}) : \$data";
#                }
#            } else {
#                if ($rt_sv) {
#                    $expr = "($rule->{expr_match}) ? ['$rule->{name}', $rule->{expr_coerce}] : ($expr)";
#                } else {
#                    $expr = "($rule->{expr_match}) ? ($rule->{expr_coerce}) : ($expr)";
#                }
#            }
#        }
#
#        $code = join(
#            "",
#            $code_require,
#            "sub {\n",
#            "    my \$data = shift;\n",
#            ($rt_sv ?
#                 "    return [undef, undef] unless defined(\$data);\n" :
#                 "    return undef unless defined(\$data);\n"
#             ),
#            "    $expr;\n",
#            "}",
#        );
#    } else {
#        if ($rt_sv) {
#            $code = 'sub { [undef, $_[0]] }';
#        } else {
#            $code = 'sub { $_[0] }';
#        }
#    }
#
#    if ($Log_Coercer_Code) {
#        $log->tracef("Coercer code (gen args: %s): %s", \%args, $code);
#    }
#
#    return $code if $args{source};
#
#    my $coercer = eval $code;
#    die if $@;
#    $coercer;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/js/bool/float.pm ###
#package Data::Sah::Coerce::js::bool::float;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#
#    my $res = {};
#
#    $res->{expr_match} = join(
#        " && ",
#        "typeof($dt)=='number'",
#        "$dt == 0 || $dt == 1",
#    );
#
#
#    $res->{expr_coerce} = "$dt == 1 ? true : false";
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/js/bool/str.pm ###
#package Data::Sah::Coerce::js::bool::str;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#
#    my $res = {};
#
#    my $re      = '/^(yes|no|true|false|on|off|1|0)$/i';
#    my $re_true = '/^(yes|true|on|1)$/i';
#
#    $res->{expr_match} = join(
#        " && ",
#        "typeof($dt)=='string'",
#        "$dt.match($re)",
#    );
#
#
#    $res->{expr_coerce} = "(function(_m) { _m = $dt.match($re); return _m[1].match($re_true) ? true : false })()";
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/js/date/float_epoch.pm ###
#package Data::Sah::Coerce::js::date::float_epoch;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#
#    my $res = {};
#
#    $res->{expr_match} = join(
#        " && ",
#        "typeof($dt)=='number'",
#        "$dt >= " . (10**8),
#        "$dt <= " . (2**31),
#    );
#
#    $res->{expr_coerce} = "(new Date($dt * 1000))";
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/js/date/obj_Date.pm ###
#package Data::Sah::Coerce::js::date::obj_Date;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        might_die => 1, 
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#
#    my $res = {};
#
#    $res->{expr_match} = join(
#        " && ",
#        "($dt instanceof Date)",
#    );
#
#    $res->{expr_coerce} = "isNaN($dt) ? (function(){throw new Error('Invalid date')})() : $dt";
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/js/date/str.pm ###
#package Data::Sah::Coerce::js::date::str;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        might_die => 1, 
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#
#    my $res = {};
#
#    $res->{expr_match} = join(
#        " && ",
#        "typeof($dt)=='string'",
#    );
#
#    $res->{expr_coerce} = "(function (_m) { _m = new Date($dt); if (isNaN(_m)) throw new Error('Invalid date'); return _m })()";
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/js/duration/float_secs.pm ###
#package Data::Sah::Coerce::js::duration::float_secs;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#    my $coerce_to = $args{coerce_to};
#
#    my $res = {};
#
#    $res->{expr_match} = join(
#        " && ",
#        "(typeof($dt)=='number' || typeof($dt)=='string' && $dt.match(/^[0-9]+(?:\\.[0-9]+)?\$/))",
#        "parseFloat($dt) >= 0", 
#        "!isNaN(parseFloat($dt))",
#        "isFinite(parseFloat($dt))", 
#    );
#
#    $res->{expr_coerce} = "parseFloat($dt)";
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/js/duration/str_iso8601.pm ###
#package Data::Sah::Coerce::js::duration::str_iso8601;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#    my $coerce_to = $args{coerce_to};
#
#    my $res = {};
#
#    my $re_num = '[0-9]+(?:\\.[0-9]+)?';
#    my $expr_re_match = "$dt.match(/^P(?:($re_num)Y)?(?:($re_num)M)?(?:($re_num)W)?(?:($re_num)D)?(?:T(?:($re_num)H)?(?:($re_num)M)?(?:($re_num)S)?)?\$/)";
#    $res->{expr_match} = join(
#        " && ",
#        "typeof($dt)=='string'",
#        $expr_re_match,
#    );
#
#
#    $res->{expr_coerce} = "(function(_m) { _m = $expr_re_match; return ((_m[1]||0)*365.25*86400 + (_m[2]||0)*30.4375*86400 + (_m[3]||0)*7*86400 + (_m[4]||0)*86400 + (_m[5]||0)*3600 + (_m[6]||0)*60 + (_m[7]||0)*1) })()";
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/perl/bool/str.pm ###
#package Data::Sah::Coerce::perl::bool::str;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 0,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#
#    my $res = {};
#
#    $res->{expr_match} = join(
#        " && ",
#        "1",
#    );
#
#    $res->{expr_coerce} = "$dt =~ /\\A(yes|true|on)\\z/i ? 1 : $dt =~ /\\A(no|false|off|0)\\z/i ? '' : $dt";
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/perl/date/float_epoch.pm ###
#package Data::Sah::Coerce::perl::date::float_epoch;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#    my $coerce_to = $args{coerce_to} // 'float(epoch)';
#
#    my $res = {};
#
#    $res->{expr_match} = join(
#        " && ",
#        "!ref($dt)",
#        "$dt =~ /\\A[0-9]{8,10}(?:\.[0-9]+)?\\z/",
#        "$dt >= 10**8",
#        "$dt <= 2**31",
#    );
#
#    if ($coerce_to eq 'float(epoch)') {
#        $res->{expr_coerce} = $dt;
#    } elsif ($coerce_to eq 'DateTime') {
#        $res->{modules}{DateTime} //= 0;
#        $res->{expr_coerce} = "DateTime->from_epoch(epoch => $dt)";
#    } elsif ($coerce_to eq 'Time::Moment') {
#        $res->{modules}{'Time::Moment'} //= 0;
#        $res->{expr_coerce} = "Time::Moment->from_epoch($dt)";
#    } else {
#        die "BUG: Unknown coerce_to value '$coerce_to', ".
#            "please use float(epoch), DateTime, or Time::Moment";
#    }
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/perl/date/obj_DateTime.pm ###
#package Data::Sah::Coerce::perl::date::obj_DateTime;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#    my $coerce_to = $args{coerce_to} // 'float(epoch)';
#
#    my $res = {};
#
#    $res->{modules}{'Scalar::Util'} //= 0;
#
#    $res->{expr_match} = join(
#        " && ",
#        "Scalar::Util::blessed($dt)",
#        "$dt\->isa('DateTime')",
#    );
#
#    if ($coerce_to eq 'float(epoch)') {
#        $res->{expr_coerce} = "$dt\->epoch";
#    } elsif ($coerce_to eq 'DateTime') {
#        $res->{expr_coerce} = $dt;
#    } elsif ($coerce_to eq 'Time::Moment') {
#        $res->{modules}{'Time::Moment'} //= 0;
#        $res->{expr_coerce} = "Time::Moment->from_object($dt)";
#    } else {
#        die "BUG: Unknown coerce_to value '$coerce_to', ".
#            "please use float(epoch), DateTime, or Time::Moment";
#    }
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/perl/date/obj_TimeMoment.pm ###
#package Data::Sah::Coerce::perl::date::obj_TimeMoment;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#    my $coerce_to = $args{coerce_to} // 'float(epoch)';
#
#    my $res = {};
#
#    $res->{modules}{'Scalar::Util'} //= 0;
#
#    $res->{expr_match} = join(
#        " && ",
#        "Scalar::Util::blessed($dt)",
#        "$dt\->isa('Time::Moment')",
#    );
#
#    if ($coerce_to eq 'float(epoch)') {
#        $res->{expr_coerce} = "$dt\->epoch";
#    } elsif ($coerce_to eq 'DateTime') {
#        $res->{modules}{'DateTime'} //= 0;
#        $res->{expr_coerce} = "DateTime->from_epoch(epoch => $dt\->epoch, time_zone => sprintf('%s%04d', $dt\->offset >= 0 ? '+':'-', abs(int($dt\->offset / 60)*100) + abs(int($dt\->offset % 60))))";
#    } elsif ($coerce_to eq 'Time::Moment') {
#        $res->{expr_coerce} = $dt;
#    } else {
#        die "BUG: Unknown coerce_to value '$coerce_to', ".
#            "please use float(epoch), DateTime, or Time::Moment";
#    }
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/perl/date/str_iso8601.pm ###
#package Data::Sah::Coerce::perl::date::str_iso8601;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        might_die => 1, 
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#    my $coerce_to = $args{coerce_to} // 'float(epoch)';
#
#    my $res = {};
#
#    $res->{expr_match} = join(
#        " && ",
#        "!ref($dt)",
#        "$dt =~ /\\A([0-9]{4})-([0-9]{2})-([0-9]{2})(?:(T)([0-9]{2}):([0-9]{2}):([0-9]{2})(Z?))?\\z/",
#    );
#
#    $res->{modules}{"Time::Local"} //= 0;
#
#    my $code_epoch = '$4 ? ($8 ? Time::Local::timegm($7, $6, $5, $3, $2-1, $1-1900) : Time::Local::timelocal($7, $6, $5, $3, $2-1, $1-1900)) : Time::Local::timelocal(0, 0, 0, $3, $2-1, $1-1900)';
#    if ($coerce_to eq 'float(epoch)') {
#        $res->{expr_coerce} = $code_epoch;
#    } elsif ($coerce_to eq 'DateTime') {
#        $res->{modules}{"DateTime"} //= 0;
#        $res->{expr_coerce} = "DateTime->from_epoch(epoch => $code_epoch, time_zone => \$8 ? 'UTC' : 'local')";
#    } elsif ($coerce_to eq 'Time::Moment') {
#        $res->{modules}{"Time::Moment"} //= 0;
#        $res->{expr_coerce} = "Time::Moment->from_epoch($code_epoch)";
#    } else {
#        die "BUG: Unknown coerce_to value '$coerce_to', ".
#            "please use float(epoch), DateTime, or Time::Moment";
#    }
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/perl/duration/float_secs.pm ###
#package Data::Sah::Coerce::perl::duration::float_secs;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#    my $coerce_to = $args{coerce_to} // 'float(secs)';
#
#    my $res = {};
#
#    $res->{expr_match} = join(
#        " && ",
#        "!ref($dt)",
#        "$dt =~ /\\A[0-9]+(?:\.[0-9]+)\\z/",
#    );
#
#    if ($coerce_to eq 'float(secs)') {
#        $res->{expr_coerce} = $dt;
#    } elsif ($coerce_to eq 'DateTime::Duration') {
#        $res->{modules}{'DateTime::Duration'} //= 0;
#        $res->{expr_coerce} = "DateTime::Duration->new(seconds => $dt)";
#    } else {
#        die "BUG: Unknown coerce_to value '$coerce_to', ".
#            "please use float(secs) or DateTime::Duration";
#    }
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/perl/duration/obj_DateTimeDuration.pm ###
#package Data::Sah::Coerce::perl::duration::obj_DateTimeDuration;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#    my $coerce_to = $args{coerce_to} // 'float(secs)';
#
#    my $res = {};
#
#    $res->{modules}{'Scalar::Util'} //= 0;
#
#    $res->{expr_match} = join(
#        " && ",
#        "Scalar::Util::blessed($dt)",
#        "$dt\->isa('DateTime::Duration')",
#    );
#
#    if ($coerce_to eq 'float(secs)') {
#        $res->{expr_coerce} = "($dt\->years * 365.25*86400 + $dt\->months * 30.4375*86400 + $dt\->weeks * 7*86400 + $dt\->days * 86400 + $dt\->hours * 3600 + $dt\->minutes * 60 + $dt\->seconds + $dt\->nanoseconds * 1e-9)";
#    } elsif ($coerce_to eq 'DateTime::Duration') {
#        $res->{expr_coerce} = $dt;
#    } else {
#        die "BUG: Unknown coerce_to value '$coerce_to', ".
#            "please use float(secs) or DateTime::Duration";
#    }
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/perl/duration/str_human.pm ###
#package Data::Sah::Coerce::perl::duration::str_human;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        might_die => 1, 
#        prio => 60,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#    my $coerce_to = $args{coerce_to} // 'float(secs)';
#
#    my $res = {};
#
#    $res->{expr_match} = join(
#        " && ",
#        "!ref($dt)",
#        "$dt =~ /\\d.*[a-z]/",
#    );
#
#    $res->{modules}{"Time::Duration::Parse::AsHash"} //= 0;
#    if ($coerce_to eq 'float(secs)') {
#        $res->{expr_coerce} = "do { my \$p = Time::Duration::Parse::AsHash::parse_duration($dt); (\$p->{years}||0) * 365.25*86400 + (\$p->{months}||0) * 30.4375*86400 + (\$p->{weeks}||0) * 7*86400 + (\$p->{days}||0) * 86400 + (\$p->{hours}||0) * 3600 + (\$p->{minutes}||0) * 60 + (\$p->{seconds}||0) }";
#    } elsif ($coerce_to eq 'DateTime::Duration') {
#        $res->{modules}{"DateTime::Duration"} //= 0;
#        $res->{expr_coerce} = "do { my \$p = Time::Duration::Parse::AsHash::parse_duration($dt); DateTime::Duration->new( (years=>\$p->{years}) x !!defined(\$p->{years}), (months=>\$p->{months}) x !!defined(\$p->{months}), (weeks=>\$p->{weeks}) x !!defined(\$p->{weeks}), (days=>\$p->{days}) x !!defined(\$p->{days}), (hours=>\$p->{hours}) x !!defined(\$p->{hours}), (minutes=>\$p->{minutes}) x !!defined(\$p->{minutes}), (seconds=>\$p->{seconds}) x !!defined(\$p->{seconds})) }";
#    } else {
#        die "BUG: Unknown coerce_to value '$coerce_to', ".
#            "please use float(secs) or DateTime::Duration";
#    }
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Coerce/perl/duration/str_iso8601.pm ###
#package Data::Sah::Coerce::perl::duration::str_iso8601;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#sub meta {
#    +{
#        v => 2,
#        enable_by_default => 1,
#        prio => 50,
#    };
#}
#
#sub coerce {
#    my %args = @_;
#
#    my $dt = $args{data_term};
#    my $coerce_to = $args{coerce_to} // 'float(secs)';
#
#    my $res = {};
#
#    my $re_num = '[0-9]+(?:\\.[0-9]+)?';
#    $res->{expr_match} = join(
#        " && ",
#        "!ref($dt)",
#        "$dt =~ /\\AP(?:($re_num)Y)? (?:($re_num)M)? (?:($re_num)W)? (?:($re_num)D)? (?: T (?:($re_num)H)? (?:($re_num)M)? (?:($re_num)S)? )?\\z/x",
#    );
#
#    if ($coerce_to eq 'float(secs)') {
#        $res->{expr_coerce} = "((\$1||0)*365.25*86400 + (\$2||0)*30.4375*86400 + (\$3||0)*7*86400 + (\$4||0)*86400 + (\$5||0)*3600 + (\$6||0)*60 + (\$7||0))";
#    } elsif ($coerce_to eq 'DateTime::Duration') {
#        $res->{modules}{"DateTime::Duration"} //= 0;
#        $res->{expr_coerce} = "DateTime::Duration->new( (years=>\$1) x !!defined(\$1), (months=>\$2) x !!defined(\$2), (weeks=>\$3) x !!defined(\$3), (days=>\$4) x !!defined(\$4), (hours=>\$5) x !!defined(\$5), (minutes=>\$6) x !!defined(\$6), (seconds=>\$7) x !!defined(\$7))";
#    } else {
#        die "BUG: Unknown coerce_to value '$coerce_to', ".
#            "please use float(secs) or DateTime::Duration";
#    }
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/CoerceCommon.pm ###
#package Data::Sah::CoerceCommon;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict 'subs', 'vars';
#
#my %common_args = (
#    type => {
#        schema => 'str*', 
#            req => 1,
#        pos => 0,
#    },
#    coerce_to => {
#        schema => 'str*',
#        description => <<'_',
#
#Some Sah types, like `date`, can be represented in a choice of types in the
#target language. For example, in Perl you can store it as a floating number
#a.k.a. `float(epoch)`, or as a <pm:DateTime> object, or <pm:Time::Moment>
#object. Storing in DateTime can be convenient for date manipulation but requires
#an overhead of loading the module and storing in a bulky format. The choice is
#yours to make, via this setting.
#
#_
#    },
#    coerce_rules => {
#        summary => 'A specification of coercion rules to use (or avoid)',
#        schema => ['array*', of=>'str*'],
#        description => <<'_',
#
#This setting is used to specify which coercion rules to use (or avoid) in a
#flexible way. Each element is a string, in the form of either `NAME` to mean
#specifically include a rule, or `!NAME` to exclude a rule, or `REGEX` or
#`!REGEX` to include or exclude a pattern. All NAME's that contains a
#non-alphanumeric, non-underscore character are assumed to be a REGEX pattern.
#
#Without this setting, the default is to use all available coercion
#rules that have `enabled_by_default` set to 1 in their metadata.
#
#To use all rules (even those that are not enabled by default):
#
#    ['.']
#
#To not use any rules:
#
#    ['!.']
#
#To use only rules named R1 and R2 and not any other rules (even
#enabled-by-default ones):
#
#    ['!.', 'R1', 'R2']
#
#To use only rules matching /^R/ and not any other rules (even
#enabled-by-default ones):
#
#    ['!.', '^R']
#
#To use the default rules plus R1 and R2:
#
#    ['R1', 'R2']
#
#To use the default rules plus rules matching /^R/:
#
#    ['^R']
#
#To use the default rules but not R1 and R2:
#
#    ['!R1', '!R2']
#
#To use the default rules but not rules matching /^R/:
#
#    ['!^R']
#
#_
#    },
#);
#
#my %gen_coercer_args = (
#    %common_args,
#    return_type => {
#        schema => ['str*', in=>[qw/val str+val/]],
#        default => 'val',
#        description => <<'_',
#
#`val` returns the value (possibly) coerced. `str+val` returns a 2-element array
#where the first element is a bool value of whether the value has been coerced,
#and the second element is the (possibly) coerced value.
#
#_
#    },
#    source => {
#        summary => 'If set to true, will return coercer source code string'.
#            ' instead of compiled code',
#        schema => 'bool',
#    },
#);
#
#my %rule_modules_cache; 
#sub _list_rule_modules {
#    my $compiler = shift;
#    return $rule_modules_cache{$compiler} if $rule_modules_cache{$compiler};
#    require PERLANCAR::Module::List;
#    my $prefix = "Data::Sah::Coerce::$compiler\::";
#    my $mods = PERLANCAR::Module::List::list_modules(
#        $prefix, {list_modules=>1, recurse=>1},
#    );
#    $rule_modules_cache{$compiler} = $mods;
#    $mods;
#}
#
#our %SPEC;
#
#$SPEC{get_coerce_rules} = {
#    v => 1.1,
#    summary => 'Get coerce rules',
#    description => <<'_',
#
#This routine lists coerce rule modules, filters out unwanted ones, loads the
#rest, filters out old (version < current) modules or ones that are not enabled
#by default. Finally the routine gets the rules out.
#
#This common routine is used by <pm:Data::Sah> compilers, as well as
#<pm:Data::Sah::Coerce> and <pm:Data::Sah::CoerceJS>.
#
#_
#    args => {
#        %common_args,
#        compiler => {
#            schema => 'str*',
#            req => 1,
#        },
#        data_term => {
#            schema => 'str*',
#            req => 1,
#        },
#    },
#};
#sub get_coerce_rules {
#    my %args = @_;
#
#    my $type     = $args{type};
#    my $compiler = $args{compiler};
#    my $dt       = $args{data_term};
#
#    my $all_mods = _list_rule_modules($compiler);
#
#    my $typen = $type; $typen =~ s/::/__/g;
#    my $prefix = "Data::Sah::Coerce::$compiler\::$typen\::";
#
#    my @available_rule_names;
#    for my $mod (keys %$all_mods) {
#        next unless $mod =~ /\A\Q$prefix\E(.+)/;
#        push @available_rule_names, $1;
#    }
#
#    my @used_rule_names = @available_rule_names;
#    my %explicitly_used_rule_names;
#    for my $item (@{ $args{coerce_rules} // [] }) {
#        my $is_exclude = $item =~ s/\A!//;
#        my $is_re;
#        if ($item =~ /\A[A-Za-z0-9_]+\z/) {
#            $is_re = 0;
#        } else {
#            $is_re = 1;
#            eval { $item = qr/$item/ };
#            die "Invalid regex in coerce_rules item '$item': $@" if $@;
#        }
#        if ($is_exclude) {
#            if ($is_re) {
#                my @r;
#                for my $r (@available_rule_names) {
#                    next if $r =~ $item;
#                    push @r, $r;
#                }
#                @used_rule_names = @r;
#            } else {
#                my @r;
#                for my $r (@available_rule_names) {
#                    next if $r eq $item;
#                    push @r, $r;
#                }
#                @used_rule_names = @r;
#            }
#        } else {
#            if ($is_re) {
#                for my $r (@available_rule_names) {
#                    next unless $r =~ $item;
#                    $explicitly_used_rule_names{$r}++;
#                    unless (grep { $_ eq $r } @used_rule_names) {
#                        push @used_rule_names, $r;
#                    }
#                }
#            } else {
#                die "Unknown coercion rule '$item', make sure the coercion ".
#                    "rule module (Data::Sah::Coerce::$compiler\::$type\::$item".
#                    " has been installed"
#                    unless grep { $_ eq $item } @available_rule_names;
#                push @used_rule_names, $item
#                    unless grep { $_ eq $item } @used_rule_names;
#                $explicitly_used_rule_names{$item}++;
#            }
#        }
#    }
#
#    my @rules;
#    for my $rule_name (@used_rule_names) {
#        my $mod = "$prefix$rule_name";
#        my $mod_pm = $mod; $mod_pm =~ s!::!/!g; $mod_pm .= ".pm";
#        require $mod_pm;
#        my $rule_meta = &{"$mod\::meta"};
#        my $rule_v = ($rule_meta->{v} // 1);
#        if ($rule_v != 2) {
#            warn "Coercion rule module '$mod' is still at ".
#                "metadata version $rule_v, will not be used";
#            next;
#        }
#        next unless $explicitly_used_rule_names{$rule_name} ||
#            $rule_meta->{enable_by_default};
#        my $rule = &{"$mod\::coerce"}(
#            data_term => $dt,
#            coerce_to => $args{coerce_to},
#        );
#        $rule->{name} = $rule_name;
#        $rule->{meta} = $rule_meta;
#        $rule->{explicitly_used} =
#            $explicitly_used_rule_names{$rule_name} ? 1:0;
#        push @rules, $rule;
#    }
#
#    @rules = sort {
#        ($a->{meta}{prio}//50) <=> ($b->{meta}{prio}//50) ||
#            $a cmp $b
#        } @rules;
#
#    {
#        my $i = 0;
#        while ($i < @rules) {
#            my $rule = $rules[$i];
#            if ($rule->{meta}{precludes}) {
#                for my $j (reverse 0 .. $#rules) {
#                    next if $j == $i;
#                    my $match;
#                    for my $p (@{ $rule->{meta}{precludes} }) {
#                        if (ref($p) eq 'Regexp' && $rules[$j]{name} =~ $p ||
#                                $rules[$j]{name} eq $p) {
#                            $match = 1;
#                            last;
#                        }
#                    }
#                    next unless $match;
#                    warn "Coercion rule $rules[$j]{name} is precluded by rule $rule->{name}"
#                        if $rule->{explicitly_used} && $rules[$j]{explicitly_used};
#                    splice @rules, $j, 1;
#                }
#            }
#            $i++;
#        }
#    }
#
#    \@rules;
#}
#
#1;
#
#__END__
#
### Data/Sah/CoerceJS.pm ###
#package Data::Sah::CoerceJS;
#
#our $DATE = '2016-09-29'; 
#our $VERSION = '0.020'; 
#
#use 5.010001;
#use strict;
#use warnings;
#use Log::Any::IfLOG '$log';
#
#use Data::Sah::CoerceCommon;
#use IPC::System::Options;
#use Nodejs::Util qw(get_nodejs_path);
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(gen_coercer);
#
#our %SPEC;
#
#our $Log_Coercer_Code = $ENV{LOG_SAH_COERCER_CODE} // 0;
#
#$SPEC{gen_coercer} = {
#    v => 1.1,
#    summary => 'Generate coercer code',
#    description => <<'_',
#
#This is mostly for testing. Normally the coercion rules will be used from
#<pm:Data::Sah>.
#
#_
#    args => {
#        %Data::Sah::CoerceCommon::gen_coercer_args,
#    },
#    result_naked => 1,
#};
#sub gen_coercer {
#    my %args = @_;
#
#    my $rt = $args{return_type} // 'val';
#    my $rt_sv = $rt eq 'str+val';
#
#    my $rules = Data::Sah::CoerceCommon::get_coerce_rules(
#        %args,
#        compiler=>'js',
#        data_term=>'data',
#    );
#
#    my $code;
#    if (@$rules) {
#        my $expr;
#        for my $i (reverse 0..$#{$rules}) {
#            my $rule = $rules->[$i];
#            if ($i == $#{$rules}) {
#                if ($rt_sv) {
#                    $expr = "($rule->{expr_match}) ? [\"$rule->{name}\", $rule->{expr_coerce}] : [null, data]";
#                } else {
#                    $expr = "($rule->{expr_match}) ? ($rule->{expr_coerce}) : data";
#                }
#            } else {
#                if ($rt_sv) {
#                    $expr = "($rule->{expr_match}) ? [\"$rule->{name}\", $rule->{expr_coerce}] : ($expr)";
#                } else {
#                    $expr = "($rule->{expr_match}) ? ($rule->{expr_coerce}) : ($expr)";
#                }
#            }
#        }
#
#        $code = join(
#            "",
#            "function (data) {\n",
#            ($rt_sv ?
#                 "    if (data === undefined || data === null) return [null, null];\n" :
#                 "    if (data === undefined || data === null) return null;\n"
#             ),
#            "    return ($expr);\n",
#            "}",
#        );
#    } else {
#        if ($rt_sv) {
#            $code = 'function (data) { return [null, data] }';
#        } else {
#            $code = 'function (data) { return data }';
#        }
#    }
#
#    if ($Log_Coercer_Code) {
#        $log->tracef("Coercer code (gen args: %s): %s", \%args, $code);
#    }
#
#    return $code if $args{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 coercer = $code;\n\n".
#            "console.log(JSON.stringify(coercer(".
#                $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 $out = IPC::System::Options::readpipe($nodejs_path, $jsfn);
#        $json->decode($out);
#    };
#}
#
#1;
#
#__END__
#
### Data/Sah/Compiler.pm ###
#package Data::Sah::Compiler;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use 5.010;
#use strict;
#use warnings;
#
#use Mo qw(default);
#use Role::Tiny::With;
#use Log::Any::IfLOG qw($log);
#use Scalar::Util qw(blessed);
#
#our %coercer_cache; 
#
#with 'Data::Sah::Compiler::TextResultRole';
#
#has main => (is => 'rw');
#
#has expr_compiler => (
#    is => 'rw',
#    lazy => 1,
#    default => sub {
#        require Language::Expr;
#        Language::Expr->new;
#    },
#);
#
#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;
#}
#
#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 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 %rsched = 
#        (); 
#    \%rsched;
#}
#
#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".
#                            ($@ ? ": $@" : ""));
#        }
#        $self->add_compile_module($cd, $module, {category=>'type_handler'});
#
#        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->{v} = 2;
#    $cd->{args} = \%args;
#    $cd->{compiler} = $self;
#    $cd->{compiler_name} = $self->name;
#
#    if (my $ocd = $args{outer_cd}) {
#        $cd->{is_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_raw_value}   = $cv;
#
#    local $cd->{cl_value_coerced_from};
#    {
#        last if $ie;
#        my $coerce_type = $meta->{schema}[0] or last;
#        my $value_is_array;
#        if ($coerce_type eq '_same') {
#            $coerce_type = $cd->{type};
#        } elsif ($coerce_type eq '_same_elem') {
#            $coerce_type = $cd->{nschema}[1]{of} //
#                $cd->{nschema}[1]{each_elem} // 'any';
#        } elsif ($clause eq 'between' || $clause eq 'xbetween') { 
#            $coerce_type = $cd->{type};
#            $value_is_array = 1;
#        }
#        my $coercer = $coercer_cache{$coerce_type};
#        if (!$coercer) {
#            require Data::Sah::Coerce;
#            $coercer = Data::Sah::Coerce::gen_coercer(
#                type => $coerce_type,
#                return_type=>'str+val',
#                (coerce_to => $cd->{coerce_to}) x !!$cd->{coerce_to},
#            );
#            $coercer_cache{$coerce_type} = $coercer;
#        }
#        if ($op && ($op eq 'or' || $op eq 'and')) {
#            for my $cv2 (@$cv) {
#                my $cf;
#                if ($value_is_array) {
#                    $cv2 = [@$cv2]; 
#                    for (@$cv2) {
#                        ($cf, $_) = @{ $coercer->($_) };
#                        $cd->{cl_value_coerced_from} //= $cf;
#                    }
#                } else {
#                    ($cf, $cv) = @{ $coercer->($cv) };
#                    $cd->{cl_value_coerced_from} //= $cf;
#                }
#            }
#        } else {
#            if ($value_is_array) {
#                $cv = [@$cv]; 
#                for (@$cv) {
#                    my $cf;
#                    ($cf, $_) = @{ $coercer->($_) };
#                    $cd->{cl_value_coerced_from} //= $cf;
#                }
#            } else {
#                ($cd->{cl_value_coerced_from}, $cv) = @{ $coercer->($cv) };
#            }
#        }
#    }
#
#    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: $_");
#            }
#        }
#        $cd->{coerce_to} //= $clset->{'x.perl.coerce_to'} if $clset->{'x.perl.coerce_to'};
#        push @{ $cd->{uclsets} }, {
#            map {$_=>$clset->{$_}}
#                grep {
#                    !/\A_|\._|\Ax\./ && (!/\Ac\./ || /\Ac\.\Q$cname\E\./)
#                } keys %$clset
#        };
#        my $dl = $clset->{default_lang} //
#            ($cd->{outer_cd} ? $cd->{outer_cd}{clset_dlang} : undef) //
#                "en_US";
#        push @{ $cd->{_clset_dlangs} }, $dl;
#    }
#
#    my $clauses = $self->_get_clauses_from_clsets($cd, $clsets);
#    $cd->{has_constraint_clause} = 0;
#    $cd->{has_subschema} = 0;
#    for my $cl (@$clauses) {
#        next if $cl->[1] =~ /\A(req|forbidden)\z/;
#        $cd->{has_subschema} = 1 if $cl->[2]{subschema};
#        if ($cl->[2]{tags} && grep {$_ eq 'constraint'} @{ $cl->[2]{tags} }) {
#            $cd->{has_constraint_clause} = 1;
#        }
#    }
#
#    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);
#            }
#        }
#    }
#
#    require Data::Sah::Resolve;
#    my $res       = Data::Sah::Resolve::resolve_schema(
#        {
#            schema_is_normalized => 1,
#        }, $nschema);
#    my $tn        = $res->[0];
#    $cd->{th}     = $self->get_th(name=>$tn, cd=>$cd);
#    $cd->{type}   = $tn;
#    $cd->{clsets} = $res->[1];
#    if ($nschema->[0] ne $tn) {
#        $self->add_compile_module($cd, "Sah::Schema::$nschema->[0]");
#    }
#
#    $self->_process_clsets($cd);
#
#    if ($self->can("after_compile")) {
#        $self->after_compile($cd);
#    }
#
#    if ($args{log_result}) {
#        $log->tracef(
#            "Schema compilation result:\n%s",
#            !ref($cd->{result}) && ($ENV{LINENUM} // 1) ?
#                __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");
#}
#
#sub add_module {
#    my ($self, $cd, $name, $extra_keys, $allow_duplicate) = @_;
#
#    my $found;
#    for (@{ $cd->{modules} }) {
#        if ($_->{name} eq $name && $_->{phase} eq $extra_keys->{phase}) {
#            $found++;
#            last;
#        }
#    }
#    return if $found && !$allow_duplicate;
#    push @{ $cd->{modules} }, {
#        name => $name,
#        %{ $extra_keys // {} },
#    };
#}
#
#sub add_runtime_module {
#    my ($self, $cd, $name, $extra_keys, $allow_duplicate) = @_;
#
#    if ($extra_keys) {
#        $extra_keys = { %$extra_keys, phase => 'runtime' };
#    } else {
#        $extra_keys = { phase => 'runtime' };
#    }
#    $self->add_module($cd, $name, $extra_keys, $allow_duplicate);
#}
#
#sub add_compile_module {
#    my ($self, $cd, $name, $extra_keys, $allow_duplicate) = @_;
#
#    if ($extra_keys) {
#        $extra_keys = { %$extra_keys, phase => 'compile' };
#    } else {
#        $extra_keys = { phase => 'compile' };
#    }
#    $self->add_module($cd, $name, $extra_keys, $allow_duplicate);
#}
#
#1;
#
#__END__
#
### Data/Sah/Compiler/Prog.pm ###
#package Data::Sah::Compiler::Prog;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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};
#        $cd->{use_dpath} = 1 if $ocd->{use_dpath};
#    } 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\+val|bool|str\+val|str|full)\z/) {
#        $self->_die({}, "Invalid value for return_type, ".
#                        "use bool|bool+val|str|str+val|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}";
#    $args->{coerce}     //= 1;
#}
#
#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_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 !~ /\Abool/) {
#        my ($ev) = $et =~ /(\w+)/; 
#        $self->add_var($cd, $ev, $rt =~ /\Astr/ ? undef : {});
#    }
#    my $resv = '_sahv_res';
#    my $rest = $self->var_sigil . $resv;
#
#    my $needs_expr_block = (grep {$_->{phase} eq 'runtime'} @{ $cd->{modules} })
#                                || $do_log;
#
#    my $code = join(
#        "",
#        ($self->stmt_require_log_module."\n") x !!$do_log,
#        (map { $self->stmt_require_module($_)."\n" }
#             grep { $_->{phase} eq 'runtime' } @{ $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($self->expr_array($rest, $dt))."\n")
#                    x !!($rt eq 'bool+val'),
#
#                ($self->expr_set_err_str($et, $self->literal('')).";",
#                 "\n\n".$self->stmt_return($self->expr_array($et, $dt))."\n")
#                    x !!($rt eq 'str+val'),
#
#                ($self->stmt_assign_hash_value($et, $self->literal('value'), $dt),
#                 "\n".$self->stmt_return($et)."\n")
#                    x !!($rt eq 'full'),
#            )
#        ),
#    );
#
#    if ($needs_expr_block) {
#        $code = $self->expr_block($code);
#    }
#
#    if ($log_result && $log->is_trace) {
#        $log->tracef("validator code:\n%s",
#                     ($ENV{LINENUM} // 1) ?
#                         Data::Sah::Compiler::__linenum($code) :
#                           $code);
#    }
#
#    $code;
#}
#
#sub add_ccl {
#    my ($self, $cd, $ccl, $opts) = @_;
#    $opts //= {};
#    my $clause = $cd->{clause} // "";
#    my $op     = $cd->{cl_op} // "";
#
#    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 $cd->{use_dpath};
#        $err_expr = $self->expr_prefix_dpath($err_expr) if $cd->{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 $cd->{use_dpath};
#            $err_expr = $self->literal($err_msg);
#            $err_expr = $self->expr_prefix_dpath($err_expr) if $cd->{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 $cd->{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 =~ /\Astr/) {
#        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 !~ /\Abool/) {
#                        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 =~ /\Abool/ && $ret) {
#                $res .= $true;
#            } elsif ($rt =~ /\Abool/ || !$ec) {
#                $res .= $self->enclose_paren($cc);
#            } else {
#                $res .= $self->enclose_paren(
#                    $self->enclose_paren($cc). " ? $true : ($ec,$ret)",
#                    "force");
#            }
#        }
#
#        $res = $self->expr_push_and_pop_dpath_between_expr($res)
#            if $cd->{use_dpath} && $ccl->{subdata};
#        $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;
#        die "BUG: support for non-perl compiler not yet added here"
#            unless $cd->{compiler_name} eq 'perl';
#        push @{ $cd->{ccls} }, ["(local($cd->{data_term} = $cd->{args}{data_term}), 1)"];
#    }
#}
#
#sub before_handle_type {
#    my ($self, $cd) = @_;
#
#
#    unless ($cd->{is_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) = @_;
#
#    $cd->{use_dpath} //= (
#        $cd->{args}{return_type} =~ /\Afull/ ||
#        ($cd->{args}{return_type} =~ /\Astr/ && $cd->{has_subschema})
#    );
#
#
#    my $c      = $cd->{compiler};
#    my $cname  = $c->name;
#    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}};
#    }
#
#    my $coerce_expr;
#    my $coerce_might_die;
#    my $coerce_ccl_note;
#  GEN_COERCE_EXPR:
#    {
#        last unless $cd->{args}{coerce};
#
#        use experimental 'smartmatch';
#        require Data::Sah::CoerceCommon;
#
#        my @coerce_rules;
#        for my $i (0..@$clsets-1) {
#            my $clset = $clsets->[$i];
#            push @coerce_rules,
#                @{ $clset->{"x.$cname.coerce_rules"} // [] },
#                @{ $clset->{'x.coerce_rules'} // [] };
#        }
#
#        my $rules = Data::Sah::CoerceCommon::get_coerce_rules(
#            compiler => $self->name,
#            type => $cd->{type},
#            data_term => $dt,
#            coerce_to => $cd->{coerce_to},
#            coerce_rules => \@coerce_rules,
#        );
#        last unless @$rules;
#
#        for my $i (reverse 0..$#{$rules}) {
#            my $rule = $rules->[$i];
#
#            $self->add_compile_module(
#                $cd, "Data::Sah::Coerce::$cname\::$cd->{type}::$rule->{name}",
#                {category => 'coerce'},
#            );
#
#            if ($rule->{modules}) {
#                for (keys %{ $rule->{modules} }) {
#                    $self->add_runtime_module($cd, $_, {category=>'coerce'});
#                }
#            }
#
#            if ($i == $#{$rules}) {
#                $coerce_expr = $self->expr_ternary(
#                    "($rule->{expr_match})",
#                    "($rule->{expr_coerce})",
#                    $dt,
#                );
#            } else {
#                $coerce_expr = $self->expr_ternary(
#                    "($rule->{expr_match})",
#                    "($rule->{expr_coerce})",
#                    "($coerce_expr)",
#                );
#            }
#            $coerce_might_die = 1 if $rule->{meta}{might_die};
#        }
#        $coerce_ccl_note = "coerce from: ".
#            join(", ", map {$_->{name}} @$rules) .
#            ($cd->{coerce_to} ? " # coerce to: $cd->{coerce_to}" : "");
#    } 
#
#  HANDLE_TYPE_CHECK:
#    {
#        $self->_die($cd, "BUG: type handler did not produce _ccl_check_type")
#            unless defined($cd->{_ccl_check_type});
#        local $cd->{_debug_ccl_note};
#
#
#        if ($coerce_expr) {
#            $cd->{_debug_ccl_note} = $coerce_ccl_note;
#            if ($coerce_might_die) {
#                $self->add_ccl(
#                    $cd,
#                    $self->expr_eval($self->expr_set($dt, $coerce_expr)),
#                    {
#                        err_msg => "Cannot coerce data to $cd->{type}", 
#                    },
#                );
#            } else {
#                $self->add_ccl(
#                    $cd,
#                    "(".$self->expr_set($dt, $coerce_expr).", ".$self->true.")",
#                    {
#                        err_msg => "",
#                    },
#                );
#            }
#        }
#
#        $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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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;
#
#    $expr //= $cd->{data_term};
#
#    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.")",
#                {err_msg => ''});
#}
#
#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.")",
#                    {err_msg => ''});
#    }
#}
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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::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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use 5.010;
#use strict;
#use warnings;
#
#use Mo qw(default);
#use Role::Tiny;
#
#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 ($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;
#}
#
#sub indent {
#    my ($self, $cd, $str) = @_;
#    _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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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::Installed::Tiny;
#                if (!Module::Installed::Tiny::module_installed($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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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::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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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_req_some_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 between %d and %d of these %(fields)s %s],
#            vals  => [$cv->[0], $cv->[1], $cv->[2]],
#        };
#    }
#    $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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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/perl.pm ###
#package Data::Sah::Compiler::perl;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use 5.010;
#use strict;
#use warnings;
#
#use Data::Dmp qw(dmp);
#use Mo qw(build default);
#
#extends 'Data::Sah::Compiler::Prog';
#
#our $PP;
#our $CORE;
#our $CORE_OR_PP;
#our $NO_MODULES;
#
#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;
#}
#
#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);
#
#    $self->add_runtime_no($cd, 'warnings', ["'void'"]) unless $cd->{args}{no_modules};
#
#    $cd;
#}
#
#sub true { "1" }
#
#sub false { "''" }
#
#our %known_modules = (
#    'DateTime::Duration'        => {pp=>1, core=>0},
#    'DateTime'                  => {pp=>0, core=>0},
#    'DateTime::Format::Alami'     => {pp=>1, core=>0},
#    'DateTime::Format::Alami::EN' => {pp=>1, core=>0},
#    'DateTime::Format::Alami::ID' => {pp=>1, core=>0},
#    'DateTime::Format::Natural'   => {pp=>1, core=>0},
#    'experimental'              => {pp=>1, core=>0}, 
#    'List::Util'                => {pp=>0, core=>1},
#    'Scalar::Util::Numeric'     => {pp=>0, core=>0},
#    'Scalar::Util::Numeric::PP' => {pp=>1, core=>0},
#    'Scalar::Util'              => {pp=>0, core=>1},
#    'Storable'                  => {pp=>0, core=>1},
#    'Time::Duration::Parse::AsHash' => {pp=>1, core=>0},
#    'Time::Local'               => {pp=>1, core=>1},
#    'Time::Moment'              => {pp=>0, core=>0},
#    'Time::Piece'               => {pp=>0, core=>1},
#    'warnings'                  => {pp=>1, core=>1},
#);
#
#sub add_module {
#    my ($self, $cd, $name, $extra_keys, $allow_duplicate) = @_;
#
#    if ($extra_keys->{phase} eq 'runtime') {
#        if ($cd->{args}{no_modules}) {
#            die "BUG: Use of module '$name' when compile option no_modules=1";
#        }
#
#        if ($cd->{args}{whitelist_modules} && grep { $_ eq $name } @{ $cd->{args}{whitelist_modules} }) {
#            goto PASS;
#        }
#
#        if ($cd->{args}{pp}) {
#            if (!$known_modules{$name}) {
#                die "BUG: Haven't noted about Perl module '$name' as being pp/xs";
#            } elsif (!$known_modules{$name}{pp}) {
#                die "Use of XS module '$name' when compile option pp=1";
#            }
#        }
#
#        if ($cd->{args}{core}) {
#            if (!$known_modules{$name}) {
#                die "BUG: Haven't noted about Perl module '$name' as being core/non-core";
#            } elsif (!$known_modules{$name}{core}) {
#                die "Use of non-core module '$name' when compile option core=1";
#            }
#        }
#
#        if ($cd->{args}{core_or_pp}) {
#            if (!$known_modules{$name}) {
#                die "BUG: Haven't noted about Perl module '$name' as being core/non-core or pp/xs";
#            } elsif (!$known_modules{$name}{pp} && !$known_modules{$name}{core}) {
#                die "Use of non-core XS module '$name' when compile option core_or_pp=1";
#            }
#        }
#    }
#  PASS:
#    $self->SUPER::add_module($cd, $name, $extra_keys, $allow_duplicate);
#}
#
#sub add_runtime_use {
#    my ($self, $cd, $name, $import_terms) = @_;
#    my $use_statement = "use $name".
#        ($import_terms && @$import_terms ? " (".(join ",", @$import_terms).")" : "");
#
#    for my $mod (@{ $cd->{modules} }) {
#        next unless $mod->{phase} eq 'runtime';
#        return if $mod->{use_statement} &&
#            $mod->{use_statement} eq $use_statement;
#    }
#
#    $self->add_runtime_module(
#        $cd,
#        $name,
#        {
#            use_statement => $use_statement,
#        },
#        1, 
#    );
#}
#
#sub add_runtime_no {
#    my ($self, $cd, $name, $import_terms) = @_;
#
#    my $use_statement = "no $name".
#        ($import_terms && @$import_terms ? " (".(join ",", @$import_terms).")" : "");
#
#    for my $mod (@{ $cd->{modules} }) {
#        next unless $mod->{phase} eq 'runtime';
#        return if $mod->{use_statement} &&
#            $mod->{use_statement} eq $use_statement;
#    }
#
#    $self->add_runtime_module(
#        $cd,
#        $name,
#        {
#            use_statement => $use_statement,
#        },
#        1, 
#    );
#}
#
#sub add_runtime_smartmatch_pragma {
#    my ($self, $cd) = @_;
#    $self->add_runtime_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_runtime_module($cd, $cd->{_sun_module});
#}
#
#sub expr_defined {
#    my ($self, $t) = @_;
#    "defined($t)";
#}
#
#sub expr_array {
#    my ($self, @t) = @_;
#    "[".join(",", @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("",map {"[$_]"} @$_sahv_dpath).": " : "") . ' . $t;
#}
#
#sub expr_set {
#    my ($self, $l, $r) = @_;
#    "($l = $r)";
#}
#
#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_ternary {
#    my ($self, $cond_term, $true_term, $false_term) = @_;
#    "$cond_term ? $true_term : $false_term";
#}
#
#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",
#        __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",
#        __indent(
#            $self->indent_character,
#            join(
#                "",
#                ("my (".join(", ", @$args).") = \@_;\n") x !!@$args,
#                $code,
#            ),
#        ),
#        "}"
#    );
#}
#
#sub expr_eval {
#    my ($self, $stmt) = @_;
#    "(eval { $stmt }, !\$@)";
#}
#
#sub stmt_require_module {
#    my ($self, $mod_record) = @_;
#
#    if ($mod_record->{use_statement}) {
#        return "$mod_record->{use_statement};";
#    } else {
#        "require $mod_record->{name};";
#    }
#}
#
#sub stmt_require_log_module {
#    my ($self) = @_;
#    'use Log::Any qw($log);';
#}
#
#sub stmt_assign_hash_value {
#    my ($self, $ht, $kt, $vt) = @_;
#    "$ht\->{$kt} = $vt;";
#}
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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;
#
#    $c->add_runtime_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}++;
#    $iargs{data_term_includes_topic_var} = 1;
#    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 !!$cd->{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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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_runtime_module($cd, 'Storable');
#
#    if ($which eq 'is') {
#        $c->add_ccl($cd, "$FRZ($dt) eq $FRZ($ct)");
#    } elsif ($which eq 'in') {
#        $c->add_runtime_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_runtime_smartmatch_pragma($cd);
#
#        $c->add_ccl($cd, "$ct ~~ $dt");
#    } elsif ($which eq 'each_index') {
#        $self_th->set_tmp_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#        $self_th->gen_each($cd, "0..\@{$cd->{data_term}}-1", '_', '$_');
#        $self_th->restore_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#    } elsif ($which eq 'each_elem') {
#        $self_th->set_tmp_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#        $self_th->gen_each($cd, "0..\@{$cd->{data_term}}-1", '_', "$cd->{data_term}\->[\$_]");
#        $self_th->restore_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#    } 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 $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 !!$cd->{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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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_runtime_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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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_runtime_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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 handle_type {
#    my ($self, $cd) = @_;
#    my $c  = $self->compiler;
#    my $dt = $cd->{data_term};
#
#    $cd->{coerce_to} = $cd->{nschema}[1]{"x.perl.coerce_to"} // 'float(epoch)';
#
#    my $coerce_to = $cd->{coerce_to};
#
#    if ($coerce_to eq 'float(epoch)') {
#        $cd->{_ccl_check_type} = "!ref($dt) && $dt =~ /\\A[0-9]+\\z/";
#    } elsif ($coerce_to eq 'DateTime') {
#        $c->add_runtime_module($cd, 'Scalar::Util');
#        $cd->{_ccl_check_type} = "Scalar::Util::blessed($dt) && $dt\->isa('DateTime')";
#    } elsif ($coerce_to eq 'Time::Moment') {
#        $c->add_runtime_module($cd, 'Scalar::Util');
#        $cd->{_ccl_check_type} = "Scalar::Util::blessed($dt) && $dt\->isa('Time::Moment')";
#    } else {
#        die "BUG: Unknown coerce_to value '$coerce_to', use either ".
#            "float(epoch), DateTime, or Time::Moment";
#    }
#}
#
#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 ($cd->{cl_is_expr}) {
#        $c->_die($cd, "date's comparison with expression not yet supported");
#    }
#
#    my $coerce_to = $cd->{coerce_to};
#    if ($coerce_to eq 'float(epoch)') {
#        if ($which eq 'is') {
#            $c->add_ccl($cd, "$dt == $ct");
#        } elsif ($which eq 'in') {
#            $c->add_runtime_module($cd, 'List::Util');
#            $c->add_ccl($cd, "List::Util::first(sub{$dt == \$_}, $ct)");
#        }
#    } elsif ($coerce_to eq 'DateTime') {
#        my $ect = "DateTime->from_epoch(epoch=>".$cv->epoch.")";
#
#        if ($which eq 'is') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect)==0");
#        } elsif ($which eq 'in') {
#            $c->add_runtime_module($cd, 'List::Util');
#            $c->add_ccl($cd, "List::Util::first(sub{DateTime->compare($dt, \$_)==0}, $ect)");
#        }
#    } elsif ($coerce_to eq 'Time::Moment') {
#        my $ect = "Time::Moment->from_epoch(".$cv->epoch.")";
#
#        if ($which eq 'is') {
#            $c->add_ccl($cd, "$dt\->compare($ect)==0");
#        } elsif ($which eq 'in') {
#            $c->add_runtime_module($cd, 'List::Util');
#            $c->add_ccl($cd, "List::Util::first(sub{$dt\->compare(\$_)==0}, $ect)");
#        }
#    }
#}
#
#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");
#    }
#
#    my $coerce_to = $cd->{coerce_to};
#    if ($coerce_to eq 'float(epoch)') {
#        if ($which eq 'min') {
#            $c->add_ccl($cd, "$dt >= $cv");
#        } elsif ($which eq 'xmin') {
#            $c->add_ccl($cd, "$dt > $cv");
#        } elsif ($which eq 'max') {
#            $c->add_ccl($cd, "$dt <= $cv");
#        } elsif ($which eq 'xmax') {
#            $c->add_ccl($cd, "$dt < $cv");
#        } elsif ($which eq 'between') {
#            $c->add_ccl($cd, "$dt >= $cv->[0] && $dt <= $cv->[1]");
#        } elsif ($which eq 'xbetween') {
#            $c->add_ccl($cd, "$dt >  $cv->[0] && $dt <  $cv->[1]");
#        }
#    } elsif ($coerce_to eq 'DateTime') {
#        my ($ect, $ect0, $ect1);
#        if (ref($cv) eq 'ARRAY') {
#            $ect0 = "DateTime->from_epoch(epoch=>".$cv->[0]->epoch.")";
#            $ect1 = "DateTime->from_epoch(epoch=>".$cv->[1]->epoch.")";
#        } else {
#            $ect = "DateTime->from_epoch(epoch=>".$cv->epoch.")";
#        }
#
#        if ($which eq 'min') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect) >= 0");
#        } elsif ($which eq 'xmin') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect) > 0");
#        } elsif ($which eq 'max') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect) <= 0");
#        } elsif ($which eq 'xmax') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect) < 0");
#        } elsif ($which eq 'between') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect0) >= 0 && DateTime->compare($dt, $ect1) <= 0");
#        } elsif ($which eq 'xbetween') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect0) >  0 && DateTime->compare($dt, $ect1) <  0");
#        }
#    } elsif ($coerce_to eq 'Time::Moment') {
#        my ($ect, $ect0, $ect1);
#        if (ref($cv) eq 'ARRAY') {
#            $ect0 = "Time::Moment->from_epoch(".$cv->[0]->epoch.")";
#            $ect1 = "Time::Moment->from_epoch(".$cv->[1]->epoch.")";
#        } else {
#            $ect = "Time::Moment->from_epoch(".$cv->epoch.")";
#        }
#
#        if ($which eq 'min') {
#            $c->add_ccl($cd, "$dt\->compare($ect) >= 0");
#        } elsif ($which eq 'xmin') {
#            $c->add_ccl($cd, "$dt\->compare($ect) > 0");
#        } elsif ($which eq 'max') {
#            $c->add_ccl($cd, "$dt\->compare($ect) <= 0");
#        } elsif ($which eq 'xmax') {
#            $c->add_ccl($cd, "$dt\->compare($ect) < 0");
#        } elsif ($which eq 'between') {
#            $c->add_ccl($cd, "$dt\->compare($ect0) >= 0 && $dt\->compare($ect1) <= 0");
#        } elsif ($which eq 'xbetween') {
#            $c->add_ccl($cd, "$dt\->compare($ect0) >  0 && $dt\->compare($ect1) <  0");
#        }
#    }
#}
#
#1;
#
#__END__
#
### Data/Sah/Compiler/perl/TH/duration.pm ###
#package Data::Sah::Compiler::perl::TH::duration;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 handle_type {
#    my ($self, $cd) = @_;
#    my $c  = $self->compiler;
#    my $dt = $cd->{data_term};
#
#    $cd->{coerce_to} = $cd->{nschema}[1]{"x.perl.coerce_to"} // 'float(secs)';
#
#    my $coerce_to = $cd->{coerce_to};
#
#    if ($coerce_to eq 'float(secs)') {
#        $cd->{_ccl_check_type} = "!ref($dt) && $dt =~ /\\A[0-9]+(?:\.[0-9]+)?\\z/"; 
#    } elsif ($coerce_to eq 'DateTime::Duration') {
#        $c->add_runtime_module($cd, 'Scalar::Util');
#        $cd->{_ccl_check_type} = "Scalar::Util::blessed($dt) && $dt\->isa('DateTime::Duration')";
#    } else {
#        die "BUG: Unknown coerce_to value '$coerce_to', use either ".
#            "float(secs) or DateTime::Duration";
#    }
#}
#
#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 ($cd->{cl_is_expr}) {
#        $c->_die($cd, "duration's comparison with expression not yet supported");
#    }
#
#    my $coerce_to = $cd->{coerce_to};
#    if ($coerce_to eq 'float(secs)') {
#        if ($which eq 'is') {
#            $c->add_ccl($cd, "$dt == $ct"); 
#        } elsif ($which eq 'in') {
#            $c->add_runtime_module('List::Util');
#            $c->add_ccl($cd, "List::Util::first(sub{$dt == \$_}, $ct)"); 
#        }
#    } elsif ($coerce_to eq 'DateTime::Duration') {
#        my $ect = join(
#            "",
#            "DateTime::Duration->new(",
#            "years => "  .$cv->years.",",
#            "months => " .$cv->months.",",
#            "weeks => "  .$cv->weeks.",",
#            "days => "   .$cv->days.",",
#            "hours => "  .$cv->hours.",",
#            "minutes => ".$cv->minutes.",",
#            "seconds => ".$cv->seconds.",",
#            ")",
#        );
#
#        if ($which eq 'is') {
#            $c->add_ccl($cd, "DateTime::Duration->compare($dt, $ect)==0");
#        } elsif ($which eq 'in') {
#            $c->add_runtime_module('List::Util');
#            $c->add_ccl($cd, "List::Util::first(sub{DateTime::Duration->compare($dt, \$_)==0}, $ect)");
#        }
#    }
#}
#
#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, "duration's comparison with expression not yet supported");
#    }
#
#    my $coerce_to = $cd->{coerce_to};
#    if ($coerce_to eq 'float(secs)') {
#        if ($which eq 'min') {
#            $c->add_ccl($cd, "$dt >= $cv");
#        } elsif ($which eq 'xmin') {
#            $c->add_ccl($cd, "$dt > $cv");
#        } elsif ($which eq 'max') {
#            $c->add_ccl($cd, "$dt <= $cv");
#        } elsif ($which eq 'xmax') {
#            $c->add_ccl($cd, "$dt < $cv");
#        } elsif ($which eq 'between') {
#            $c->add_ccl($cd, "$dt >= $cv->[0] && $dt <= $cv->[1]");
#        } elsif ($which eq 'xbetween') {
#            $c->add_ccl($cd, "$dt >  $cv->[0] && $dt <  $cv->[1]");
#        }
#    } elsif ($coerce_to eq 'DateTime::Duration') {
#        my ($ect, $ect0, $ect1);
#        if (ref($cv) eq 'ARRAY') {
#            $ect0 = join(
#                "",
#                "DateTime::Duration->new(",
#                "years => "  .$cv->[0]->years.",",
#                "months => " .$cv->[0]->months.",",
#                "weeks => "  .$cv->[0]->weeks.",",
#                "days => "   .$cv->[0]->days.",",
#                "hours => "  .$cv->[0]->hours.",",
#                "minutes => ".$cv->[0]->minutes.",",
#                "seconds => ".$cv->[0]->seconds.",",
#                ")",
#            );
#            $ect1 = join(
#                "",
#                "DateTime::Duration->new(",
#                "years => "  .$cv->[1]->years.",",
#                "months => " .$cv->[1]->months.",",
#                "weeks => "  .$cv->[1]->weeks.",",
#                "days => "   .$cv->[1]->days.",",
#                "hours => "  .$cv->[1]->hours.",",
#                "minutes => ".$cv->[1]->minutes.",",
#                "seconds => ".$cv->[1]->seconds.",",
#                ")",
#            );
#        } else {
#            $ect = join(
#                "",
#                "DateTime::Duration->new(",
#                "years => "  .$cv->years.",",
#                "months => " .$cv->months.",",
#                "weeks => "  .$cv->weeks.",",
#                "days => "   .$cv->days.",",
#                "hours => "  .$cv->hours.",",
#                "minutes => ".$cv->minutes.",",
#                "seconds => ".$cv->seconds.",",
#                ")",
#            );
#        }
#
#        if ($which eq 'min') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect) >= 0");
#        } elsif ($which eq 'xmin') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect) > 0");
#        } elsif ($which eq 'max') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect) <= 0");
#        } elsif ($which eq 'xmax') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect) < 0");
#        } elsif ($which eq 'between') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect0) >= 0 && DateTime->compare($dt, $ect1) <= 0");
#        } elsif ($which eq 'xbetween') {
#            $c->add_ccl($cd, "DateTime->compare($dt, $ect0) >  0 && DateTime->compare($dt, $ect1) <  0");
#        }
#    }
#}
#
#1;
#
#__END__
#
### Data/Sah/Compiler/perl/TH/float.pm ###
#package Data::Sah::Compiler::perl::TH::float;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use 5.010;
#use strict;
#use warnings;
#
#use Data::Dmp;
#
#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_runtime_module($cd, 'Storable');
#
#    if ($which eq 'is') {
#        $c->add_ccl($cd, "$FRZ($dt) eq $FRZ($ct)");
#    } elsif ($which eq 'in') {
#        $c->add_runtime_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_runtime_smartmatch_pragma($cd);
#
#        $c->add_ccl($cd, "$ct ~~ [values \%{ $dt }]");
#    } elsif ($which eq 'each_index') {
#        $self_th->set_tmp_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#        $self_th->gen_each($cd, "sort keys(\%{$cd->{data_term}})", '', '$_');
#        $self_th->restore_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#    } elsif ($which eq 'each_elem') {
#        $self_th->set_tmp_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#        $self_th->gen_each($cd, "sort keys(\%{$cd->{data_term}})", '_', "$cd->{data_term}\->{\$_}");
#        $self_th->restore_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#    } 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 $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)."]";
#        }
#
#        $self_th->set_tmp_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#
#        if ($cd->{clset}{"$which.restrict"} // 1) {
#            local $cd->{_debug_ccl_note} = "$which.restrict";
#            $c->add_runtime_module($cd, "List::Util");
#            $c->add_runtime_smartmatch_pragma($cd);
#            $c->add_ccl(
#                $cd,
#                "!defined(List::Util::first(sub {!(\$_ ~~ $lit_valid_keys)}, ".
#                    "keys %{$cd->{data_term}}))",
#                {
#                    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 %{$cd->{data_term}})",
#                        ')',
#                    ),
#                },
#            );
#            $self_th->restore_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#        }
#        delete $cd->{uclset}{"$which.restrict"};
#
#        my $cdef;
#        if ($which eq 'keys') {
#            $cdef = $cd->{clset}{"keys.create_default"} // 1;
#            delete $cd->{uclset}{"keys.create_default"};
#        }
#
#        $self_th->set_tmp_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#
#        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 = "$cd->{data_term}\->{$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}++;
#            $iargs{data_term_includes_topic_var} = 1 if $which eq 're_keys';
#            my $icd = $c->compile(%iargs);
#
#            my $sdef = $cdef && defined($sch->[1]{default});
#
#            $c->add_var($cd, '_sahv_stack', []) if $cd->{use_dpath};
#
#            my @code = (
#                ($c->indent_str($cd), "(push(@\$_sahv_dpath, undef), push(\@\$_sahv_stack, undef), \$_sahv_stack->[-1] = \n")
#                    x !!($cd->{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 !!$cd->{use_dpath},
#                $icd->{result}, "\n",
#
#                $which eq 're_keys' || !$sdef ? ")" : "",
#
#                (")}, sort keys %{ $cd->{data_term} })))")
#                    x !!($which eq 're_keys'),
#
#                ($c->indent_str($cd), "), pop(\@\$_sahv_dpath), pop(\@\$_sahv_stack)\n")
#                    x !!($cd->{use_dpath} && $i == $nkeys),
#            );
#            my $ires = join("", @code);
#            local $cd->{_debug_ccl_note} = "$which: ".$c->literal($k);
#            $c->add_ccl($cd, $ires);
#        }
#
#        $self_th->restore_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#
#        $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_runtime_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_runtime_module($cd, "List::Util");
#    $c->add_runtime_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_runtime_module($cd, "List::Util");
#    $c->add_runtime_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_runtime_module($cd, "List::Util");
#    $c->add_runtime_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_runtime_module($cd, "List::Util");
#    $c->add_runtime_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_runtime_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_runtime_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_runtime_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_req_some_keys {
#    my ($self, $cd) = @_;
#    my $c  = $self->compiler;
#    my $cv = $cd->{cl_value};
#    my $dt = $cd->{data_term};
#
#
#    $c->add_runtime_module($cd, "List::Util");
#    $c->add_ccl(
#      $cd,
#      "do { my \$_sahv_h = $dt; my \$_sahv_n = List::Util::sum(map {exists(\$_sahv_h\->{\$_}) ? 1:0} \@{ ".$c->literal($cv->[2])." }); \$_sahv_n >= $cv->[0] && \$_sahv_n <= $cv->[1] }",
#      {},
#    );
#}
#
#sub clause_dep_any {
#    my ($self, $cd) = @_;
#    my $c  = $self->compiler;
#    my $ct = $cd->{cl_term};
#    my $dt = $cd->{data_term};
#
#
#    $c->add_runtime_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_runtime_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_runtime_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_runtime_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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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_runtime_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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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_runtime_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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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_runtime_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->set_tmp_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#        $self_th->gen_each($cd, "0..length($cd->{data_term})-1", '_', '$_');
#        $self_th->restore_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#    } elsif ($which eq 'each_elem') {
#        $self_th->set_tmp_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#        $self_th->gen_each($cd, "0..length($cd->{data_term})-1", '_', "substr($cd->{data_term}, \$_, 1)");
#        $self_th->restore_data_term($cd) if $cd->{args}{data_term_includes_topic_var};
#    } 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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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/Lang.pm ###
#package Data::Sah::Lang;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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]],
#
#    q[Cannot coerce data to %s [%s]],
#    q[Data tidak dapat dikonversi ke %s [%%s]],
#);
#
#1;
#
#__END__
#
### Data/Sah/Lang/zh_CN.pm ###
#package Data::Sah::Lang::zh_CN;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use 5.010;
#use strict;
#use utf8;
#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/Resolve.pm ###
#package Data::Sah::Resolve;
#
#our $DATE = '2016-07-26'; 
#our $VERSION = '0.004'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(resolve_schema);
#
#sub _resolve {
#    my ($opts, $type, $clsets, $seen) = @_;
#
#    die "Recursive schema definition: ".join(" -> ", @$seen, $type)
#        if grep { $type eq $_ } @$seen;
#    push @$seen, $type;
#
#    (my $typemod_pm = "Data/Sah/Type/$type.pm") =~ s!::!/!g;
#    eval { require $typemod_pm; 1 };
#    return [$type, $clsets] unless $@;
#
#    my $schmod = "Sah::Schema::$type";
#    (my $schmod_pm = "$schmod.pm") =~ s!::!/!g;
#    eval { require $schmod_pm; 1 };
#    die "Not a known type/schema name '$type'" if $@;
#    no strict 'refs';
#    my $sch2 = ${"$schmod\::schema"};
#    die "BUG: Schema module $schmod doesn't contain \$schema" unless $sch2;
#    unshift @$clsets, $sch2->[1];
#    _resolve($opts, $sch2->[0], $clsets, $seen);
#}
#
#sub resolve_schema {
#    my $opts = ref($_[0]) eq 'HASH' ? shift : {};
#    my $sch = shift;
#
#    unless ($opts->{schema_is_normalized}) {
#        require Data::Sah::Normalize;
#        $sch =  Data::Sah::Normalize::normalize_schema($sch);
#    }
#    $opts->{merge_clause_sets} //= 1;
#
#    my $seen = [];
#    my $res = _resolve($opts, $sch->[0], keys(%{$sch->[1]}) ? [$sch->[1]] : [], $seen);
#
#  MERGE:
#    {
#        last unless $opts->{merge_clause_sets};
#        last if @{ $res->[1] } < 2;
#
#        my @clsets = (shift @{ $res->[1] });
#        for my $clset (@{ $res->[1] }) {
#            my $has_merge_mode_keys;
#            for (keys %$clset) {
#                if (/\Amerge\./) {
#                    $has_merge_mode_keys = 1;
#                    last;
#                }
#            }
#            if ($has_merge_mode_keys) {
#                state $merger = do {
#                    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;
#                };
#                my $merge_res = $merger->merge($clsets[-1], $clset);
#                unless ($merge_res->{success}) {
#                    die "Can't merge clause set: $merge_res->{error}";
#                }
#                $clsets[-1] = $merge_res->{result};
#            } else {
#                push @clsets, $clset;
#            }
#        }
#
#        $res->[1] = \@clsets;
#    }
#
#    $res->[2] = $seen if $opts->{return_intermediates};
#
#    $res;
#}
#
#1;
#
#__END__
#
### Data/Sah/Type/BaseType.pm ###
#package Data::Sah::Type::BaseType;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#
#use 5.010;
#use strict;
#use warnings;
#
#use Data::Sah::Util::Role 'has_clause';
#use Role::Tiny;
#
#requires 'handle_type';
#
#has_clause 'v',
#    v => 2,
#    prio   => 0,
#    tags   => ['meta', 'defhash'],
#    schema => ['float'=>{req=>1, is=>1}, {}],
#    ;
#
#has_clause 'defhash_v',
#    v => 2,
#    prio   => 0,
#    tags   => ['meta', 'defhash'],
#    schema => ['float'=>{req=>1, is=>1}, {}],
#    ;
#
#has_clause 'schema_v',
#    v => 2,
#    prio   => 0,
#    tags   => ['meta'],
#    schema => ['float'=>{req=>1}, {}],
#    ;
#
#has_clause 'base_v',
#    v => 2,
#    prio   => 0,
#    tags   => ['meta'],
#    schema => ['float'=>{req=>1}, {}],
#    ;
#
#has_clause 'ok',
#    v => 2,
#    tags       => ['constraint'],
#    prio       => 1,
#    schema     => ['any', {}, {}],
#    allow_expr => 1,
#    ;
#has_clause 'default',
#    v => 2,
#    prio       => 1,
#    tags       => ['default'],
#    schema     => ['any', {}, {}],
#    allow_expr => 1,
#    attrs      => {
#        temp => {
#            schema     => [bool => {default=>0}, {}],
#            allow_expr => 0,
#        },
#    },
#    ;
#has_clause 'default_lang',
#    v => 2,
#    tags       => ['meta', 'defhash'],
#    prio       => 2,
#    schema     => ['str'=>{req=>1, default=>'en_US'}, {}],
#    ;
#has_clause 'name',
#    v => 2,
#    tags       => ['meta', 'defhash'],
#    prio       => 2,
#    schema     => ['str', {req=>1}, {}],
#    ;
#has_clause 'summary',
#    v => 2,
#    prio       => 2,
#    tags       => ['meta', 'defhash'],
#    schema     => ['str', {req=>1}, {}],
#    ;
#has_clause 'description',
#    v => 2,
#    tags       => ['meta', 'defhash'],
#    prio       => 2,
#    schema     => ['str', {req=>1}, {}],
#    ;
#has_clause 'tags',
#    v => 2,
#    tags       => ['meta', 'defhash'],
#    prio       => 2,
#    schema     => ['array', {of=>['str', {req=>1}, {}]}, {}],
#    ;
#has_clause 'req',
#    v => 2,
#    tags       => ['constraint'],
#    prio       => 3,
#    schema     => ['bool', {}, {}],
#    allow_expr => 1,
#    ;
#has_clause 'forbidden',
#    v => 2,
#    tags       => ['constraint'],
#    prio       => 3,
#    schema     => ['bool', {}, {}],
#    allow_expr => 1,
#    ;
#
#
#
#
#
#
#has_clause 'clause',
#    v => 2,
#    tags       => ['constraint'],
#    prio       => 50,
#    schema     => ['array' => {req=>1, len=>2, elems => [
#        ['sah::clname', {req=>1}, {}],
#        ['any', {}, {}],
#    ]}, {}],
#    ;
#has_clause 'clset',
#    v => 2,
#    prio   => 50,
#    tags   => ['constraint'],
#    schema => ['sah::clset', {req=>1}, {}],
#    ;
#
#1;
#
#__END__
#
### Data/Sah/Type/Comparable.pm ###
#package Data::Sah::Type::Comparable;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use Data::Sah::Util::Role 'has_clause';
#use Role::Tiny;
#
#requires 'superclause_comparable';
#
#has_clause 'in',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['array', {req=>1, of=>['_same', {req=>1}, {}]}, {}],
#    allow_expr => 1,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_comparable('in', $cd);
#    };
#has_clause 'is',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['_same', {req=>1}, {}],
#    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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use Data::Sah::Util::Role 'has_clause';
#use Role::Tiny;
#
#requires 'superclause_has_elems';
#
#has_clause 'max_len',
#    v => 2,
#    prio       => 51,
#    tags       => ['constraint'],
#    schema     => ['int', {min=>0}, {}],
#    allow_expr => 1,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_has_elems('max_len', $cd);
#    };
#
#has_clause 'min_len',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['int', {min=>0}, {}],
#    allow_expr => 1,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_has_elems('min_len', $cd);
#    };
#
#has_clause 'len_between',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['array' => {req=>1, len=>2, elems => [
#        [int => {req=>1}, {}],
#        [int => {req=>1}, {}],
#    ]}, {}],
#    allow_expr => 1,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_has_elems('len_between', $cd);
#    };
#
#has_clause 'len',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['int', {min=>0}, {}],
#    allow_expr => 1,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_has_elems('len', $cd);
#    };
#
#has_clause 'has',
#    v => 2,
#    tags       => ['constraint'],
#    schema       => ['_same_elem', {req=>1}, {}],
#    inspect_elem => 1,
#    prio         => 55, 
#    allow_expr   => 1,
#    code         => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_has_elems('has', $cd);
#    };
#
#has_clause 'each_index',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['sah::schema', {req=>1}, {}],
#    subschema  => sub { $_[0] },
#    allow_expr => 0,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_has_elems('each_index', $cd);
#    };
#
#has_clause 'each_elem',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['sah::schema', {req=>1}, {}],
#    inspect_elem => 1,
#    subschema  => sub { $_[0] },
#    allow_expr => 0,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_has_elems('each_elem', $cd);
#    };
#
#has_clause 'check_each_index',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['sah::schema', {req=>1}, {}],
#    subschema  => sub { $_[0] },
#    allow_expr => 0,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_has_elems('check_each_index', $cd);
#    };
#
#has_clause 'check_each_elem',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['sah::schema', {req=>1}, {}],
#    inspect_elem => 1,
#    subschema  => sub { $_[0] },
#    allow_expr => 0,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_has_elems('check_each_elem', $cd);
#    };
#
#has_clause 'uniq',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['bool', {}, {}],
#    inspect_elem => 1,
#    prio         => 55, 
#    subschema  => sub { $_[0] },
#    allow_expr => 1,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_has_elems('uniq', $cd);
#    };
#
#has_clause 'exists',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['sah::schema', {req=>1}, {}],
#    inspect_elem => 1,
#    subschema  => sub { $_[0] },
#    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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use Data::Sah::Util::Role 'has_clause';
#use Role::Tiny;
#
#requires 'superclause_sortable';
#
#has_clause 'min',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['_same', {req=>1}, {}],
#    allow_expr => 1,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_sortable('min', $cd);
#    },
#    ;
#has_clause 'xmin',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['_same', {req=>1}, {}],
#    allow_expr => 1,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_sortable('xmin', $cd);
#    },
#    ;
#has_clause 'max',
#    v => 2,
#    prio       => 51,
#    tags       => ['constraint'],
#    schema     => ['_same', {req=>1}, {}],
#    allow_expr => 1,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_sortable('max', $cd);
#    },
#    ;
#has_clause 'xmax',
#    v => 2,
#    prio       => 51,
#    tags       => ['constraint'],
#    schema     => ['_same', {req=>1}, {}],
#    allow_expr => 1,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_sortable('xmax', $cd);
#    },
#    ;
#has_clause 'between',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['array', {req=>1, len=>2, elems=>[
#        ['_same', {req=>1}, {}],
#        ['_same', {req=>1}, {}],
#    ]}, {}],
#    allow_expr => 1,
#    code       => sub {
#        my ($self, $cd) = @_;
#        $self->superclause_sortable('between', $cd);
#    },
#    ;
#has_clause 'xbetween',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['array', {req=>1, len=>2, elems=>[
#        ['_same', {req=>1}, {}],
#        ['_same', {req=>1}, {}],
#    ]}, {}],
#    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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use Data::Sah::Util::Role 'has_clause';
#use Role::Tiny;
#use Role::Tiny::With;
#
#with 'Data::Sah::Type::BaseType';
#
#has_clause 'of',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['array' => {req=>1, min_len=>1, each_elem => ['sah::schema', {req=>1}, {}]}, {}],
#    subschema  => sub { @{ $_[0] } },
#    allow_expr => 0,
#    ;
#
#1;
#
#__END__
#
### Data/Sah/Type/any.pm ###
#package Data::Sah::Type::any;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use Data::Sah::Util::Role 'has_clause';
#use Role::Tiny;
#use Role::Tiny::With;
#
#with 'Data::Sah::Type::BaseType';
#
#has_clause 'of',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['array' => {req=>1, min_len=>1, each_elem => ['sah::schema', {req=>1}, {}]}, {}],
#    subschema  => sub { @{ $_[0] } },
#    allow_expr => 0,
#    ;
#
#1;
#
#__END__
#
### Data/Sah/Type/array.pm ###
#package Data::Sah::Type::array;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['array' => {req=>1, of=>['sah::schema', {req=>1}, {}]}, {}],
#    inspect_elem => 1,
#    allow_expr => 0,
#    subschema  => sub { @{ $_[0] } },
#    attrs      => {
#        create_default => {
#            schema     => [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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['bool', {}, {}],
#    allow_expr => 1,
#    ;
#
#1;
#
#__END__
#
### Data/Sah/Type/buf.pm ###
#package Data::Sah::Type::buf;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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/float.pm ###
#package Data::Sah::Type::float;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use Data::Sah::Util::Role 'has_clause';
#use Role::Tiny;
#use Role::Tiny::With;
#
#with 'Data::Sah::Type::num';
#
#has_clause 'is_nan',
#    v => 2,
#    tags        => ['constraint'],
#    schema      => ['bool', {}, {}],
#    allow_expr  => 1,
#    allow_multi => 0,
#    ;
#
#has_clause 'is_inf',
#    v => 2,
#    tags        => ['constraint'],
#    schema      => ['bool', {}, {}],
#    allow_expr  => 1,
#    allow_multi => 1,
#    ;
#
#has_clause 'is_pos_inf',
#    v => 2,
#    tags        => ['constraint'],
#    schema      => ['bool', {}, {}],
#    allow_expr  => 1,
#    allow_multi => 1,
#    ;
#
#has_clause 'is_neg_inf',
#    v => 2,
#    tags        => ['constraint'],
#    schema      => ['bool', {}, {}],
#    allow_expr  => 1,
#    allow_multi => 1,
#    ;
#
#1;
#
#__END__
#
### Data/Sah/Type/hash.pm ###
#package Data::Sah::Type::hash;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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_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 "keys",
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['hash' => {req=>1, values => ['sah::schema', {req=>1}, {}]}, {}],
#    inspect_elem => 1,
#    subschema  => sub { values %{ $_[0] } },
#    allow_expr => 0,
#    attrs      => {
#        restrict => {
#            schema     => [bool => default=>1],
#            allow_expr => 0, 
#        },
#        create_default => {
#            schema     => [bool => default=>1],
#            allow_expr => 0, 
#        },
#    },
#    ;
#
#has_clause "re_keys",
#    v => 2,
#    prio       => 51,
#    tags       => ['constraint'],
#    schema     => ['hash' => {
#        req=>1,
#        keys   => ['re', {req=>1}, {}],
#        values => ['sah::schema', {req=>1}, {}],
#    }, {}],
#    inspect_elem => 1,
#    subschema  => sub { values %{ $_[0] } },
#    allow_expr => 0,
#    attrs      => {
#        restrict => {
#            schema     => [bool => default=>1],
#            allow_expr => 0, 
#        },
#    },
#    ;
#
#has_clause "req_keys",
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['array', {req=>1, of=>['str', {req=>1}, {}]}, {}],
#    allow_expr => 1,
#    ;
#has_clause_alias req_keys => 'req_all_keys';
#has_clause_alias req_keys => 'req_all';
#
#has_clause "allowed_keys",
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['array', {req=>1, of=>['str', {req=>1}, {}]}, {}],
#    allow_expr => 1,
#    ;
#
#has_clause "allowed_keys_re",
#    v => 2,
#    prio       => 51,
#    tags       => ['constraint'],
#    schema     => ['re', {req=>1}, {}],
#    allow_expr => 1,
#    ;
#
#has_clause "forbidden_keys",
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['array', {req=>1, of=>['str', {req=>1}, {}]}, {}],
#    allow_expr => 1,
#    ;
#
#has_clause "forbidden_keys_re",
#    v => 2,
#    prio       => 51,
#    tags       => ['constraint'],
#    schema     => ['re', {req=>1}, {}],
#    allow_expr => 1,
#    ;
#
#has_clause "choose_one_key",
#    v => 2,
#    prio       => 50,
#    tags       => ['constraint'],
#    schema     => ['array', {req=>1, of=>['str', {req=>1}, {}], min_len=>1}, {}],
#    allow_expr => 0, 
#    ;
#has_clause_alias choose_one_key => 'choose_one';
#
#has_clause "choose_all_keys",
#    v => 2,
#    prio       => 50,
#    tags       => ['constraint'],
#    schema     => ['array', {req=>1, of=>['str', {req=>1}, {}], min_len=>1}, {}],
#    allow_expr => 0, 
#    ;
#has_clause_alias choose_all_keys => 'choose_all';
#
#has_clause "req_one_key",
#    v => 2,
#    prio       => 50,
#    tags       => ['constraint'],
#    schema     => ['array', {req=>1, of=>['str', {req=>1}, {}], min_len=>1}, {}],
#    allow_expr => 0, 
#    ;
#has_clause_alias req_one_key => 'req_one';
#
#has_clause "req_some_keys",
#    v => 2,
#    prio       => 50,
#    tags       => ['constraint'],
#    schema     => ['array', {
#        req => 1,
#        len => 3,
#        elems => [
#            [int => {req=>1, min=>0}], 
#            [int => {req=>1, min=>0}], 
#            [array => {req=>1, of=>['str', {req=>1}, {}], min_len=>1}, {}], 
#        ],
#    }, {}],
#    allow_expr => 0, 
#    ;
#has_clause_alias req_some_keys => 'req_some';
#
#my $sch_dep = ['array', {
#    req => 1,
#    elems => [
#        ['str', {req=>1}, {}],
#        ['array', {of=>['str', {req=>1}, {}]}, {}],
#    ],
#}, {}];
#
#has_clause "dep_any",
#    v => 2,
#    prio       => 50,
#    tags       => ['constraint'],
#    schema     => $sch_dep,
#    allow_expr => 0, 
#    ;
#
#has_clause "dep_all",
#    v => 2,
#    prio       => 50,
#    tags       => ['constraint'],
#    schema     => $sch_dep,
#    allow_expr => 0, 
#    ;
#
#has_clause "req_dep_any",
#    v => 2,
#    prio       => 50,
#    tags       => ['constraint'],
#    schema     => $sch_dep,
#    allow_expr => 0, 
#    ;
#
#has_clause "req_dep_all",
#    v => 2,
#    prio       => 50,
#    tags       => ['constraint'],
#    schema     => $sch_dep,
#    allow_expr => 0, 
#    ;
#
#
#
#1;
#
#__END__
#
### Data/Sah/Type/int.pm ###
#package Data::Sah::Type::int;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use Data::Sah::Util::Role 'has_clause';
#use Role::Tiny;
#use Role::Tiny::With;
#
#with 'Data::Sah::Type::num';
#
#has_clause 'mod',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['array' => {req=>1, len=>2, elems => [
#        ['int' => {req=>1, is=>0, 'is.op'=>'not'}, {}],
#        ['int' => {req=>1}, {}],
#    ]}, {}],
#    allow_expr => 1,
#    ;
#has_clause 'div_by',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['int' => {req=>1, is=>0, 'is.op'=>'not'}, {}],
#    allow_expr => 1,
#    ;
#
#1;
#
#__END__
#
### Data/Sah/Type/num.pm ###
#package Data::Sah::Type::num;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use Data::Sah::Util::Role 'has_clause';
#use Role::Tiny;
#use Role::Tiny::With;
#
#with 'Data::Sah::Type::BaseType';
#
#has_clause 'can',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['str', {req => 1}, {}], 
#    allow_expr => 1,
#    ;
#has_clause 'isa',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['str', {req => 1}, {}], 
#    allow_expr => 1,
#    ;
#
#1;
#
#__END__
#
### Data/Sah/Type/re.pm ###
#package Data::Sah::Type::re;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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', {req=>1}, {}];
#
#has_clause 'encoding',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['str', {req=>1}, {}],
#    allow_expr => 0,
#    ;
#has_clause 'match',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => $t_re,
#    allow_expr => 1,
#    ;
#has_clause 'is_re',
#    v => 2,
#    tags       => ['constraint'],
#    schema     => ['bool', {}, {}],
#    allow_expr => 1,
#    ;
#
#1;
#
#__END__
#
### Data/Sah/Type/undef.pm ###
#package Data::Sah::Type::undef;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use Role::Tiny;
#use Data::Sah::Util::Role 'has_clause';
#
#1;
#
#__END__
#
### Data/Sah/Util/Func.pm ###
#package Data::Sah::Util::Func;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use 5.010;
#use strict 'subs', 'vars';
#use warnings;
#
#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;
#
#    my $v = $args{v} // 1;
#    if ($v != 2) {
#        die "Declaration of clause '$name' still follows version $v ".
#            "(2 expected), please make sure $caller is the latest version";
#    }
#
#    if ($args{code}) {
#        *{"$into\::clause_$name"} = $args{code};
#    } else {
#        eval "package $into; use Role::Tiny; ".
#            "requires 'clause_$name';";
#    }
#    *{"$into\::clausemeta_$name"} = sub {
#        state $meta = {
#            names        => [$name],
#            tags         => $args{tags},
#            prio         => $args{prio} // 50,
#            schema       => $args{schema},
#            allow_expr   => $args{allow_expr},
#            attrs        => $args{attrs} // {},
#            inspect_elem => $args{inspect_elem},
#            subschema    => $args{subschema},
#        };
#        $meta;
#    };
#    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}) {
#        *{"$into\::func_$name"} = $args{code};
#    } else {
#        eval "package $into; use Role::Tiny; requires 'func_$name';";
#    }
#    *{"$into\::funcmeta_$name"} = sub {
#        state $meta = {
#            names => [$name],
#            args  => $args{args},
#        };
#        $meta;
#    };
#    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 = '2016-12-09'; 
#our $VERSION = '0.46'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#require Exporter;
#our @ISA       = qw(Exporter);
#our @EXPORT_OK = qw(get_type is_type is_simple is_numeric is_collection is_ref);
#
#our $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},
#    date     => {scalar=>1, numeric=>0, ref=>0},
#    duration => {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_type {
#    my ($sch, $opts) = @_;
#    $opts //= {};
#
#    my $type = get_type($sch) or return undef;
#    my $tmeta = $type_metas->{$type} or return undef;
#    $type;
#}
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#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__
#
### Encode/Locale.pm ###
#package Encode::Locale;
#
#use strict;
#our $VERSION = "1.05";
#
#use base 'Exporter';
#our @EXPORT_OK = qw(
#    decode_argv env
#    $ENCODING_LOCALE $ENCODING_LOCALE_FS
#    $ENCODING_CONSOLE_IN $ENCODING_CONSOLE_OUT
#);
#
#use Encode ();
#use Encode::Alias ();
#
#our $ENCODING_LOCALE;
#our $ENCODING_LOCALE_FS;
#our $ENCODING_CONSOLE_IN;
#our $ENCODING_CONSOLE_OUT;
#
#sub DEBUG () { 0 }
#
#sub _init {
#    if ($^O eq "MSWin32") {
#	unless ($ENCODING_LOCALE) {
#	    eval {
#		unless (defined &GetACP) {
#		    require Win32;
#                    eval { Win32::GetACP() };
#		    *GetACP = sub { &Win32::GetACP } unless $@;
#		}
#		unless (defined &GetACP) {
#		    require Win32::API;
#		    Win32::API->Import('kernel32', 'int GetACP()');
#		}
#		if (defined &GetACP) {
#		    my $cp = GetACP();
#		    $ENCODING_LOCALE = "cp$cp" if $cp;
#		}
#	    };
#	}
#
#	unless ($ENCODING_CONSOLE_IN) {
#            unless (defined &GetInputCP) {
#                eval {
#                    require Win32;
#                    eval { Win32::GetConsoleCP() };
#                    *GetInputCP = sub { &Win32::GetConsoleCP } unless $@;
#                    *GetOutputCP = sub { &Win32::GetConsoleOutputCP } unless $@;
#                };
#                unless (defined &GetInputCP) {
#                    eval {
#                        require Win32::Console;
#                        eval { Win32::Console::InputCP() };
#                        *GetInputCP = sub { &Win32::Console::InputCP }
#                            unless $@;
#                        *GetOutputCP = sub { &Win32::Console::OutputCP }
#                            unless $@;
#                    };
#                }
#                unless (defined &GetInputCP) {
#                    *GetInputCP = *GetOutputCP = sub {
#                        ((qx(chcp) || '') =~ /^Active code page: (\d+)/)
#                            ? $1 : ();
#                    };
#                }
#	    }
#            my $cp = GetInputCP();
#            $ENCODING_CONSOLE_IN = "cp$cp" if $cp;
#            $cp = GetOutputCP();
#            $ENCODING_CONSOLE_OUT = "cp$cp" if $cp;
#	}
#    }
#
#    unless ($ENCODING_LOCALE) {
#	eval {
#	    require I18N::Langinfo;
#	    $ENCODING_LOCALE = I18N::Langinfo::langinfo(I18N::Langinfo::CODESET());
#
#	    $ENCODING_LOCALE = "ascii" if $ENCODING_LOCALE eq "646";
#
#	    $ENCODING_LOCALE = "hp-roman8" if $^O eq "hpux" && $ENCODING_LOCALE eq "roman8";
#	};
#	$ENCODING_LOCALE ||= $ENCODING_CONSOLE_IN;
#    }
#
#    if ($^O eq "darwin") {
#	$ENCODING_LOCALE_FS ||= "UTF-8";
#    }
#
#    $ENCODING_LOCALE ||= $^O eq "MSWin32" ? "cp1252" : "UTF-8";
#    $ENCODING_LOCALE_FS ||= $ENCODING_LOCALE;
#    $ENCODING_CONSOLE_IN ||= $ENCODING_LOCALE;
#    $ENCODING_CONSOLE_OUT ||= $ENCODING_CONSOLE_IN;
#
#    unless (Encode::find_encoding($ENCODING_LOCALE)) {
#	my $foundit;
#	if (lc($ENCODING_LOCALE) eq "gb18030") {
#	    eval {
#		require Encode::HanExtra;
#	    };
#	    if ($@) {
#		die "Need Encode::HanExtra to be installed to support locale codeset ($ENCODING_LOCALE), stopped";
#	    }
#	    $foundit++ if Encode::find_encoding($ENCODING_LOCALE);
#	}
#	die "The locale codeset ($ENCODING_LOCALE) isn't one that perl can decode, stopped"
#	    unless $foundit;
#
#    }
#
#}
#
#_init();
#Encode::Alias::define_alias(sub {
#    no strict 'refs';
#    no warnings 'once';
#    return ${"ENCODING_" . uc(shift)};
#}, "locale");
#
#sub _flush_aliases {
#    no strict 'refs';
#    for my $a (keys %Encode::Alias::Alias) {
#	if (defined ${"ENCODING_" . uc($a)}) {
#	    delete $Encode::Alias::Alias{$a};
#	    warn "Flushed alias cache for $a" if DEBUG;
#	}
#    }
#}
#
#sub reinit {
#    $ENCODING_LOCALE = shift;
#    $ENCODING_LOCALE_FS = shift;
#    $ENCODING_CONSOLE_IN = $ENCODING_LOCALE;
#    $ENCODING_CONSOLE_OUT = $ENCODING_LOCALE;
#    _init();
#    _flush_aliases();
#}
#
#sub decode_argv {
#    die if defined wantarray;
#    for (@ARGV) {
#	$_ = Encode::decode(locale => $_, @_);
#    }
#}
#
#sub env {
#    my $k = Encode::encode(locale => shift);
#    my $old = $ENV{$k};
#    if (@_) {
#	my $v = shift;
#	if (defined $v) {
#	    $ENV{$k} = Encode::encode(locale => $v);
#	}
#	else {
#	    delete $ENV{$k};
#	}
#    }
#    return Encode::decode(locale => $old) if defined wantarray;
#}
#
#1;
#
#__END__
#
### File/Flock/Retry.pm ###
#package File::Flock::Retry;
#
#our $DATE = '2015-10-22'; 
#our $VERSION = '0.61'; 
#
#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;
#    $h{shared}  = $opts->{shared} // 0;
#
#    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}, ($self->{shared} ? LOCK_SH : 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/Listing.pm ###
#package File::Listing;
#
#sub Version { $VERSION; }
#$VERSION = "6.04";
#
#require Exporter;
#@ISA = qw(Exporter);
#@EXPORT = qw(parse_dir);
#
#use strict;
#
#use Carp ();
#use HTTP::Date qw(str2time);
#
#
#
#sub parse_dir ($;$$$)
#{
#   my($dir, $tz, $fstype, $error) = @_;
#
#   $fstype ||= 'unix';
#   $fstype = "File::Listing::" . lc $fstype;
#
#   my @args = $_[0];
#   push(@args, $tz) if(@_ >= 2);
#   push(@args, $error) if(@_ >= 4);
#
#   $fstype->parse(@args);
#}
#
#
#sub line { Carp::croak("Not implemented yet"); }
#sub init { } 
#
#
#sub file_mode ($)
#{
#    Carp::croak("Input to file_mode() must be a 10 character string.")
#        unless length($_[0]) == 10;
#
#
#    local $_ = shift;
#    my $mode = 0;
#    my($type);
#
#    s/^(.)// and $type = $1;
#
#
#    s/[Ll](...)$/S$1/;
#
#    while (/(.)/g) {
#	$mode <<= 1;
#	$mode |= 1 if $1 ne "-" &&
#		      $1 ne 'S' &&
#		      $1 ne 'T';
#    }
#
#    $mode |= 0004000 if /^..s....../i;
#    $mode |= 0002000 if /^.....s.../i;
#    $mode |= 0001000 if /^........t/i;
#
#
#    $type eq "p" and $mode |= 0010000 or        
#    $type eq "c" and $mode |= 0020000 or        
#    $type eq "d" and $mode |= 0040000 or        
#    $type eq "b" and $mode |= 0060000 or        
#    $type eq "-" and $mode |= 0100000 or        
#    $type eq "l" and $mode |= 0120000 or        
#    $type eq "s" and $mode |= 0140000 or        
#    $type eq "D" and $mode |= 0150000 or        
#      Carp::croak("Unknown file type: $type");
#
#    $mode;
#}
#
#
#sub parse
#{
#   my($pkg, $dir, $tz, $error) = @_;
#
#
#   if (ref($dir) eq 'ARRAY') {
#   }
#   elsif (ref($dir) eq 'GLOB') {
#   }
#   elsif (ref($dir)) {
#      Carp::croak("Illegal argument to parse_dir()");
#   }
#   elsif ($dir =~ /^\*\w+(::\w+)+$/) {
#   }
#   else {
#      $dir = [ split(/\n/, $dir) ];
#   }
#
#   $pkg->init();
#
#   my @files = ();
#   if (ref($dir) eq 'ARRAY') {
#       for (@$dir) {
#	   push(@files, $pkg->line($_, $tz, $error));
#       }
#   }
#   else {
#       local($_);
#       while (<$dir>) {
#	   chomp;
#	   push(@files, $pkg->line($_, $tz, $error));
#       }
#   }
#   wantarray ? @files : \@files;
#}
#
#
#
#package File::Listing::unix;
#
#use HTTP::Date qw(str2time);
#
#use vars qw($curdir @ISA);
#
#@ISA = qw(File::Listing);
#
#
#
#sub init
#{
#    $curdir = '';
#}
#
#
#sub line
#{
#    shift; 
#    local($_) = shift;
#    my($tz, $error) = @_;
#
#    s/\015//g;
#
#    my ($kind, $size, $date, $name);
#    if (($kind, $size, $date, $name) =
#	/^([\-FlrwxsStTdD]{10})                   # Type and permission bits
#	 .*                                       # Graps
#	 \D(\d+)                                  # File size
#	 \s+                                      # Some space
#	 (\w{3}\s+\d+\s+(?:\d{1,2}:\d{2}|\d{4})|\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2})  # Date
#	 \s+                                      # Some more space
#	 (.*)$                                    # File name
#	/x )
#
#    {
#	return if $name eq '.' || $name eq '..';
#	$name = "$curdir/$name" if length $curdir;
#	my $type = '?';
#	if ($kind =~ /^l/ && $name =~ /(.*) -> (.*)/ ) {
#	    $name = $1;
#	    $type = "l $2";
#	}
#	elsif ($kind =~ /^[\-F]/) { 
#	    $type = 'f';
#	}
#	elsif ($kind =~ /^[dD]/) {
#	    $type = 'd';
#	    $size = undef;  
#	}
#	return [$name, $type, $size, str2time($date, $tz), 
#              File::Listing::file_mode($kind)];
#
#    }
#    elsif (/^(.+):$/ && !/^[dcbsp].*\s.*\s.*:$/ ) {
#	my $dir = $1;
#	return () if $dir eq '.';
#	$curdir = $dir;
#	return ();
#    }
#    elsif (/^[Tt]otal\s+(\d+)$/ || /^\s*$/) {
#	return ();
#    }
#    elsif (/not found/    || 
#             /No such file/ || 
#             /cannot find/     
#             ) {
#	return () unless defined $error;
#	&$error($_) if ref($error) eq 'CODE';
#	warn "Error: $_\n" if $error eq 'warn';
#	return ();
#    }
#    elsif ($_ eq '') {       
#	return () unless defined $error;
#	&$error("No such file or directory") if ref($error) eq 'CODE';
#	warn "Warning: No such file or directory\n" if $error eq 'warn';
#	return ();
#    }
#    else {
#        File::Listing::dosftp->init();
#        return(File::Listing::dosftp->line($_,$tz,$error));
#    }
#
#}
#
#
#
#package File::Listing::dosftp;
#
#use HTTP::Date qw(str2time);
#
#use vars qw($curdir @ISA);
#
#@ISA = qw(File::Listing);
#
#
#
#sub init
#{
#    $curdir = '';
#}
#
#
#sub line
#{
#    shift; 
#    local($_) = shift;
#    my($tz, $error) = @_;
#
#    s/\015//g;
#
#    my ($date, $size_or_dir, $name, $size);
#
#    if (($date, $size_or_dir, $name) =
#        /^(\d\d-\d\d-\d\d\s+\d\d:\d\d\wM)         # Date and time info
#         \s+                                      # Some space
#         (<\w{3}>|\d+)                            # Dir or Size
#         \s+                                      # Some more space
#         (.+)$                                    # File name
#        /x )
#    {
#	return if $name eq '.' || $name eq '..';
#	$name = "$curdir/$name" if length $curdir;
#	my $type = '?';
#	if ($size_or_dir eq '<DIR>') {
#	    $type = "d";
#            $size = ""; 
#        }
#        else {
#	    $type = 'f';
#            $size = $size_or_dir;
#	}
#	return [$name, $type, $size, str2time($date, $tz), undef];
#    }
#    else {
#	return () unless defined $error;
#	&$error($_) if ref($error) eq 'CODE';
#	warn "Can't parse: $_\n" if $error eq 'warn';
#	return ();
#    }
#
#}
#
#
#
#package File::Listing::vms;
#@File::Listing::vms::ISA = qw(File::Listing);
#
#package File::Listing::netware;
#@File::Listing::netware::ISA = qw(File::Listing);
#
#
#
#package File::Listing::apache;
#
#use vars qw(@ISA);
#
#@ISA = qw(File::Listing);
#
#
#sub init { }
#
#
#sub line {
#    shift; 
#    local($_) = shift;
#    my($tz, $error) = @_; 
#
#    s!</?t[rd][^>]*>! !g;  
#    if (m!<A\s+HREF=\"([^\"]+)\">.*</A>.*?(\d+)-([a-zA-Z]+|\d+)-(\d+)\s+(\d+):(\d+)\s+(?:([\d\.]+[kMG]?|-))!i) {
#	my($filename, $filesize) = ($1, $7);
#	my($d,$m,$y, $H,$M) = ($2,$3,$4,$5,$6);
#	if ($m =~ /^\d+$/) {
#	    ($d,$y) = ($y,$d) 
#	}
#	else {
#	    $m = _monthabbrev_number($m);
#	}
#
#	$filesize = 0 if $filesize eq '-';
#	if ($filesize =~ s/k$//i) {
#	    $filesize *= 1024;
#	}
#	elsif ($filesize =~ s/M$//) {
#	    $filesize *= 1024*1024;
#	}
#	elsif ($filesize =~ s/G$//) {
#	    $filesize *= 1024*1024*1024;
#	}
#	$filesize = int $filesize;
#
#	require Time::Local;
#	my $filetime = Time::Local::timelocal(0,$M,$H,$d,$m-1,_guess_year($y)-1900);
#	my $filetype = ($filename =~ s|/$|| ? "d" : "f");
#	return [$filename, $filetype, $filesize, $filetime, undef];
#    }
#
#    return ();
#}
#
#
#sub _guess_year {
#    my $y = shift;
#    if ($y >= 90) {
#	$y = 1900+$y;
#    }
#    elsif ($y < 100) {
#	$y = 2000+$y;
#    }
#    $y;
#}
#
#
#sub _monthabbrev_number {
#    my $mon = shift;
#    +{'Jan' => 1,
#      'Feb' => 2,
#      'Mar' => 3,
#      'Apr' => 4,
#      'May' => 5,
#      'Jun' => 6,
#      'Jul' => 7,
#      'Aug' => 8,
#      'Sep' => 9,
#      'Oct' => 10,
#      'Nov' => 11,
#      'Dec' => 12,
#     }->{$mon};
#}
#
#
#1;
#
#__END__
#
### File/RsyBak.pm ###
#package File::RsyBak;
#
#our $DATE = '2017-02-03'; 
#our $VERSION = '0.31'; 
#
#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 ",
#        ($log->is_debug ? "-v " : ""),
#        ((-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 = '2017-02-03'; 
#our $VERSION = '0.31'; 
#
#
#1;
#
#__END__
#
### File/ShareDir.pm ###
#package File::ShareDir;
#
#
#use 5.005;
#use strict;
#use warnings;
#
#use Carp             ();
#use Config           ();
#use Exporter         ();
#use File::Spec       ();
#use Class::Inspector ();
#
#use vars qw{ $VERSION @ISA @EXPORT_OK %EXPORT_TAGS };
#BEGIN {
#	$VERSION     = '1.102';
#	@ISA         = qw{ Exporter };
#	@EXPORT_OK   = qw{
#		dist_dir
#		dist_file
#		module_dir
#		module_file
#		class_dir
#		class_file
#	};
#	%EXPORT_TAGS = (
#		ALL => [ @EXPORT_OK ],
#	);
#}
#
#use constant IS_MACOS => !! ($^O eq 'MacOS');
#
#
#
#
#
#
#
#sub dist_dir {
#	my $dist = _DIST(shift);
#	my $dir;
#
#	$dir = _dist_dir_new( $dist );
#	return $dir if defined $dir;
#
#	$dir = _dist_dir_old( $dist );
#	return $dir if defined $dir;
#
#	Carp::croak("Failed to find share dir for dist '$dist'");
#}
#
#sub _dist_dir_new {
#	my $dist = shift;
#
#	my $path = File::Spec->catdir(
#		'auto', 'share', 'dist', $dist,
#	);
#
#	foreach my $inc ( @INC ) {
#		next unless defined $inc and ! ref $inc;
#		my $dir = File::Spec->catdir( $inc, $path );
#		next unless -d $dir;
#		unless ( -r $dir ) {
#			Carp::croak("Found directory '$dir', but no read permissions");
#		}
#		return $dir;
#	}
#
#	return undef;
#}
#
#sub _dist_dir_old {
#	my $dist = shift;
#
#	my $path = File::Spec->catdir(
#		'auto', split( /-/, $dist ),
#	);
#
#	foreach my $inc ( @INC ) {
#		next unless defined $inc and ! ref $inc;
#		my $dir = File::Spec->catdir( $inc, $path );
#		next unless -d $dir;
#		unless ( -r $dir ) {
#			Carp::croak("Found directory '$dir', but no read permissions");
#		}
#		return $dir;
#	}
#
#	return undef;
#}
#
#
#sub module_dir {
#	my $module = _MODULE(shift);
#	my $dir;
#
#	$dir = _module_dir_new( $module );
#	return $dir if defined $dir;
#
#	return _module_dir_old( $module );
#}
#
#sub _module_dir_new {
#	my $module = shift;
#
#	my $path = File::Spec->catdir(
#		'auto', 'share', 'module',
#		_module_subdir( $module ),
#	);
#
#	foreach my $inc ( @INC ) {
#		next unless defined $inc and ! ref $inc;
#		my $dir = File::Spec->catdir( $inc, $path );
#		next unless -d $dir;
#		unless ( -r $dir ) {
#			Carp::croak("Found directory '$dir', but no read permissions");
#		}
#		return $dir;
#	}
#
#	return undef;
#}
#	
#sub _module_dir_old {
#	my $module = shift;
#	my $short  = Class::Inspector->filename($module);
#	my $long   = Class::Inspector->loaded_filename($module);
#	$short =~ tr{/}{:} if IS_MACOS;
#	substr( $short, -3, 3, '' );
#	$long  =~ m/^(.*)\Q$short\E\.pm\z/s or die("Failed to find base dir");
#	my $dir = File::Spec->catdir( "$1", 'auto', $short );
#	unless ( -d $dir ) {
#		Carp::croak("Directory '$dir', does not exist");
#	}
#	unless ( -r $dir ) {
#		Carp::croak("Directory '$dir', no read permissions");
#	}
#	return $dir;
#}
#
#
#sub dist_file {
#	my $dist = _DIST(shift);
#	my $file = _FILE(shift);
#
#	my $path = _dist_file_new( $dist, $file );
#	return $path if defined $path;
#
#	return _dist_file_old( $dist, $file );;
#}
#
#sub _dist_file_new {
#	my $dist = shift;
#	my $file = shift;
#
#	my $dir  = _dist_dir_new( $dist );
#	my $path = File::Spec->catfile( $dir, $file );
#
#	return undef unless -e $path;
#	unless ( -f $path ) {
#		Carp::croak("Found dist_file '$path', but not a file");
#	}
#	unless ( -r $path ) {
#		Carp::croak("File '$path', no read permissions");
#	}
#
#	return $path;
#}
#
#sub _dist_file_old {
#	my $dist = shift;
#	my $file = shift;
#
#	my $path = File::Spec->catfile(
#		'auto', split( /-/, $dist ), $file,
#	);
#
#	foreach my $inc ( @INC ) {
#		next unless defined $inc and ! ref $inc;
#		my $full = File::Spec->catdir( $inc, $path );
#		next unless -e $full;
#		unless ( -r $full ) {
#			Carp::croak("Directory '$full', no read permissions");
#		}
#		return $full;
#	}
#
#	Carp::croak("Failed to find shared file '$file' for dist '$dist'");
#}
#
#
#sub module_file {
#	my $module = _MODULE(shift);
#	my $file   = _FILE(shift);
#	my $dir    = module_dir($module);
#	my $path   = File::Spec->catfile($dir, $file);
#	unless ( -e $path ) {
#		Carp::croak("File '$file' does not exist in module dir");
#	}
#	unless ( -r $path ) {
#		Carp::croak("File '$file' cannot be read, no read permissions");
#	}
#	$path;
#}
#
#
#sub class_file {
#	my $module = _MODULE(shift);
#	my $file   = _FILE(shift);
#
#	my @path  = ();
#	my @queue = ( $module );
#	my %seen  = ( $module => 1 );
#	while ( my $cl = shift @queue ) {
#		push @path, $cl;
#		no strict 'refs';
#		unshift @queue, grep { ! $seen{$_}++ }
#			map { s/^::/main::/; s/\'/::/g; $_ }
#			( @{"${cl}::ISA"} );
#	}
#
#	foreach my $class ( @path ) {
#		local $@;
#		my $dir = eval {
#		 	module_dir($class);
#		};
#		next if $@;
#		my $path = File::Spec->catfile($dir, $file);
#		unless ( -e $path ) {
#			next;
#		}
#		unless ( -r $path ) {
#			Carp::croak("File '$file' cannot be read, no read permissions");
#		}
#		return $path;
#	}
#	Carp::croak("File '$file' does not exist in class or parent shared files");
#}
#
#
#
#
#
#sub _module_subdir {
#	my $module = shift;
#	$module =~ s/::/-/g;
#	return $module;
#}
#
#sub _dist_packfile {
#	my $module = shift;
#	my @dirs   = grep { -e } ( $Config::Config{archlibexp}, $Config::Config{sitearchexp} );
#	my $file   = File::Spec->catfile(
#		'auto', split( /::/, $module), '.packlist',
#	);
#
#	foreach my $dir ( @dirs ) {
#		my $path = File::Spec->catfile( $dir, $file );
#		next unless -f $path;
#
#		my $packlist = ExtUtils::Packlist->new($path);
#		unless ( $packlist ) {
#			die "Failed to load .packlist file for $module";
#		}
#
#		die "CODE INCOMPLETE";
#	}
#
#	die "CODE INCOMPLETE";
#}
#
#sub _CLASS {
#    (defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s) ? $_[0] : undef;
#}
#
#
#
#sub _DIST {
#	if ( defined $_[0] and ! ref $_[0] and $_[0] =~ /^[a-z0-9+_-]+$/is ) {
#		return shift;
#	}
#	Carp::croak("Not a valid distribution name");
#}
#
#sub _MODULE {
#	my $module = _CLASS(shift) or Carp::croak("Not a valid module name");
#	if ( Class::Inspector->loaded($module) ) {
#		return $module;
#	}
#	Carp::croak("Module '$module' is not loaded");
#}
#
#sub _FILE {
#	my $file = shift;
#	unless ( defined $file and ! ref $file and length $file ) {
#		Carp::croak("Did not pass a file name");
#	}
#	if ( File::Spec->file_name_is_absolute($file) ) {
#		Carp::croak("Cannot use absolute file name '$file'");
#	}
#	$file;
#}
#
#1;
#
### File/ShareDir/Tarball.pm ###
#package File::ShareDir::Tarball;
#BEGIN {
#  $File::ShareDir::Tarball::AUTHORITY = 'cpan:YANICK';
#}
#{
#  $File::ShareDir::Tarball::VERSION = '0.2.2';
#}
#
#
#use strict;
#use warnings;
#
#use parent qw/ Exporter /;
#
#use Carp;
#
#use File::ShareDir;
#use Archive::Tar;
#use File::Temp qw/ tempdir /;
#use File::chdir;
#
#our @EXPORT_OK   = qw{
#    dist_dir dist_file
#};
#our %EXPORT_TAGS = (
#    all => [ @EXPORT_OK ],
#);
#
#my $shared_files_tarball = 'shared-files.tar.gz';
#
#my %DIR_CACHE;
#
#sub dist_dir {
#    my $dist = shift;
#
#    return $DIR_CACHE{$dist} if $DIR_CACHE{$dist};
#
#    my $dir = File::ShareDir::dist_dir($dist);
#
#    return $DIR_CACHE{$dist} = $dir 
#        unless -f "$dir/$shared_files_tarball";
#
#    my $archive = Archive::Tar->new;
#    $archive->read("$dir/$shared_files_tarball");
#
#    croak "archive '$shared_files_tarball' contains files with absolute path, aborting"
#        if grep { m#^/# } $archive->list_files;
#
#    my $tmpdir = tempdir( CLEANUP => 1 );
#    local $CWD = $tmpdir;
#
#    $archive->extract;
#
#    return $DIR_CACHE{$dist} = $tmpdir;
#}
#
#sub dist_file {
#    my $dist = File::ShareDir::_DIST(shift);
#    my $file = File::ShareDir::_FILE(shift);
#
#    my $path = dist_dir($dist).'/'.$file;
#
#	return undef unless -e $path;
#
#    croak("Found dist_file '$path', but not a file") 
#        unless -f $path;
#
#    croak("File '$path', no read permissions") 
#        unless -r $path;
#
#	return $path;
#}
#
#
#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/Slurper.pm ###
#package File::Slurper;
#$File::Slurper::VERSION = '0.008';
#use strict;
#use warnings;
#
#use Carp 'croak';
#use Exporter 5.57 'import';
#our @EXPORT_OK = qw/read_binary read_text read_lines write_binary write_text read_dir/;
#
#sub read_binary {
#	my $filename = shift;
#
#	open my $fh, '<:unix', $filename or croak "Couldn't open $filename: $!";
#	if (my $size = -s $fh) {
#		my $buf;
#		my ($pos, $read) = 0;
#		do {
#			defined($read = read $fh, ${$buf}, $size - $pos, $pos) or croak "Couldn't read $filename: $!";
#			$pos += $read;
#		} while ($read && $pos < $size);
#		return ${$buf};
#	}
#	else {
#		return do { local $/; <$fh> };
#	}
#}
#
#use constant {
#	CRLF_DEFAULT => $^O eq 'MSWin32',
#	HAS_UTF8_STRICT => scalar do { local $@; eval { require PerlIO::utf8_strict } },
#};
#
#sub _text_layers {
#	my ($encoding, $crlf) = @_;
#	$crlf = CRLF_DEFAULT if $crlf && $crlf eq 'auto';
#
#	if ($encoding =~ /^(latin|iso-8859-)1$/i) {
#		return $crlf ? ':unix:crlf' : ':raw';
#	}
#	elsif (HAS_UTF8_STRICT && $encoding =~ /^utf-?8\b/i) {
#		return $crlf ? ':unix:utf8_strict:crlf' : ':unix:utf8_strict';
#	}
#	else {
#		return $crlf ? ":raw:encoding($encoding):crlf" : ":raw:encoding($encoding)";
#	}
#}
#
#sub read_text {
#	my ($filename, $encoding, $crlf) = @_;
#	$encoding ||= 'utf-8';
#	my $layer = _text_layers($encoding, $crlf);
#	return read_binary($filename) if $layer eq ':raw';
#
#	local $PerlIO::encoding::fallback = 1;
#	open my $fh, "<$layer", $filename or croak "Couldn't open $filename: $!";
#	return do { local $/; <$fh> };
#}
#
#sub write_text {
#	my ($filename, undef, $encoding, $crlf) = @_;
#	$encoding ||= 'utf-8';
#	my $layer = _text_layers($encoding, $crlf);
#
#	local $PerlIO::encoding::fallback = 1;
#	open my $fh, ">$layer", $filename or croak "Couldn't open $filename: $!";
#	print $fh $_[1] or croak "Couldn't write to $filename: $!";
#	close $fh or croak "Couldn't write to $filename: $!";
#	return;
#}
#
#sub write_binary {
#	return write_text(@_[0,1], 'latin-1');
#}
#
#sub read_lines {
#	my ($filename, $encoding, $crlf, $skip_chomp) = @_;
#	$encoding ||= 'utf-8';
#	my $layer = _text_layers($encoding, $crlf);
#
#	local $PerlIO::encoding::fallback = 1;
#	open my $fh, "<$layer", $filename or croak "Couldn't open $filename: $!";
#	return <$fh> if $skip_chomp;
#	my @buf = <$fh>;
#	close $fh;
#	chomp @buf;
#	return @buf;
#}
#
#sub read_dir {
#	my ($dirname) = @_;
#	opendir my ($dir), $dirname or croak "Could not open $dirname: $!";
#	return grep { not m/ \A \.\.? \z /x } readdir $dir;
#}
#
#1;
#
#
#__END__
#
### File/Which.pm ###
#package File::Which;
#
#use strict;
#use warnings;
#use Exporter   ();
#use File::Spec ();
#
#our $VERSION = '1.21'; 
#
#
#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 defined $exec;
#  return undef if $exec eq '';
#
#  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 = '2016-10-07'; 
#our $VERSION = '0.31'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#
#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 die "Please specify dir";
#    defined($args{prefix} = delete $args0{prefix})
#        or die "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 die "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{$_});
#        die "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 die "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 die "Invalid rotate_probability, must be 0 < x < 1";
#    }
#
#    if (keys %args0) {
#        die "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, "
#                      . scalar(@{ $self->{_buffer} })
#                      . " message(s))"
#                    : ""
#                ),
#                ": $err, message(s)=",
#                @msg
#            );
#        }
#    }
#}
#
#sub compress {
#    my ($self) = shift;
#
#    my $lock           = $self->_get_lock;
#    my $files_ref        = $self->_get_files;
#    my $done_compression = 0;
#
#    if (@{$files_ref}) {
#        require Proc::PID::File;
#
#        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__
#
### File/chdir.pm ###
#package File::chdir;
#use 5.004;
#use strict;
#use vars qw($VERSION @ISA @EXPORT $CWD @CWD);
#
#our $VERSION = '0.1010';
#
#require Exporter;
#@ISA = qw(Exporter);
#@EXPORT = qw(*CWD);
#
#use Carp;
#use Cwd 3.16;
#use File::Spec::Functions 3.27 qw/canonpath splitpath catpath splitdir catdir/;
#
#tie $CWD, 'File::chdir::SCALAR' or die "Can't tie \$CWD";
#tie @CWD, 'File::chdir::ARRAY'  or die "Can't tie \@CWD";
#
#sub _abs_path {
#    my($cwd) = Cwd::getcwd =~ /(.*)/s;
#    return canonpath($cwd);
#}
#
#sub _split_cwd {
#    my ($vol, $dir) = splitpath(_abs_path, 1);
#    my @dirs = splitdir( $dir );
#    shift @dirs; 
#    return ($vol, @dirs);
#}
#
#sub _catpath {
#    my ($vol, @dirs) = @_;
#    return catpath($vol, catdir(q{}, @dirs), q{});
#}
#
#sub _chdir {
#    my ($new_dir) = $_[0] =~ /(.*)/s;
#
#    local $Carp::CarpLevel = $Carp::CarpLevel + 1;
#    if ( ! CORE::chdir($new_dir) ) {
#        croak "Failed to change directory to '$new_dir': $!";
#    };
#    return 1;
#}
#
#{
#    package File::chdir::SCALAR;
#    use Carp;
#
#    BEGIN {
#        *_abs_path = \&File::chdir::_abs_path;
#        *_chdir = \&File::chdir::_chdir;
#        *_split_cwd = \&File::chdir::_split_cwd;
#        *_catpath = \&File::chdir::_catpath;
#    }
#
#    sub TIESCALAR {
#        bless [], $_[0];
#    }
#
#    sub FETCH {
#        return _abs_path;
#    }
#
#    sub STORE {
#        return unless defined $_[1];
#        _chdir($_[1]);
#    }
#}
#
#
#{
#    package File::chdir::ARRAY;
#    use Carp;
#
#    BEGIN {
#        *_abs_path = \&File::chdir::_abs_path;
#        *_chdir = \&File::chdir::_chdir;
#        *_split_cwd = \&File::chdir::_split_cwd;
#        *_catpath = \&File::chdir::_catpath;
#    }
#
#    sub TIEARRAY {
#        bless {}, $_[0];
#    }
#
#    sub FETCH {
#        my($self, $idx) = @_;
#        my ($vol, @cwd) = _split_cwd;
#        return $cwd[$idx];
#    }
#
#    sub STORE {
#        my($self, $idx, $val) = @_;
#
#        my ($vol, @cwd) = _split_cwd;
#        if( $self->{Cleared} ) {
#            @cwd = ();
#            $self->{Cleared} = 0;
#        }
#
#        $cwd[$idx] = $val;
#        my $dir = _catpath($vol,@cwd);
#
#        _chdir($dir);
#        return $cwd[$idx];
#    }
#
#    sub FETCHSIZE {
#        my ($vol, @cwd) = _split_cwd;
#        return scalar @cwd;
#    }
#    sub STORESIZE {}
#
#    sub PUSH {
#        my($self) = shift;
#
#        my $dir = _catpath(_split_cwd, @_);
#        _chdir($dir);
#        return $self->FETCHSIZE;
#    }
#
#    sub POP {
#        my($self) = shift;
#
#        my ($vol, @cwd) = _split_cwd;
#        my $popped = pop @cwd;
#        my $dir = _catpath($vol,@cwd);
#        _chdir($dir);
#        return $popped;
#    }
#
#    sub SHIFT {
#        my($self) = shift;
#
#        my ($vol, @cwd) = _split_cwd;
#        my $shifted = shift @cwd;
#        my $dir = _catpath($vol,@cwd);
#        _chdir($dir);
#        return $shifted;
#    }
#
#    sub UNSHIFT {
#        my($self) = shift;
#
#        my ($vol, @cwd) = _split_cwd;
#        my $dir = _catpath($vol, @_, @cwd);
#        _chdir($dir);
#        return $self->FETCHSIZE;
#    }
#
#    sub CLEAR  {
#        my($self) = shift;
#        $self->{Cleared} = 1;
#    }
#
#    sub SPLICE {
#        my $self = shift;
#        my $offset = shift || 0;
#        my $len = shift || $self->FETCHSIZE - $offset;
#        my @new_dirs = @_;
#
#        my ($vol, @cwd) = _split_cwd;
#        my @orig_dirs = splice @cwd, $offset, $len, @new_dirs;
#        my $dir = _catpath($vol, @cwd);
#        _chdir($dir);
#        return @orig_dirs;
#    }
#
#    sub EXTEND { }
#    sub EXISTS {
#        my($self, $idx) = @_;
#        return $self->FETCHSIZE >= $idx ? 1 : 0;
#    }
#
#    sub DELETE {
#        my($self, $idx) = @_;
#        croak "Can't delete except at the end of \@CWD"
#            if $idx < $self->FETCHSIZE - 1;
#        local $Carp::CarpLevel = $Carp::CarpLevel + 1;
#        $self->POP;
#    }
#}
#
#1;
#
#__END__
#
### Function/Fallback/CoreOrPP.pm ###
#package Function::Fallback::CoreOrPP;
#
#use 5.010001;
#use strict;
#use warnings;
#
#our $VERSION = '0.08'; 
#
#our $USE_NONCORE_XS_FIRST = 1;
#
#require Exporter;
#our @ISA       = qw(Exporter);
#our @EXPORT_OK = qw(
#                       clone
#                       clone_list
#                       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 clone_list {
#    map { clone($_) } @_;
#}
#
#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} );
#    } elsif ($r3 eq 'CODE') {
#        return sub { goto &$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 = '2016-03-01'; 
#our $VERSION = '0.05'; 
#
#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 =~ /\Ahas([_-].+)/    ) { return ("hasnt$1")   }
#    elsif ($word =~ /\Ahave([_-].+)/   ) { return ("havent$1")  }
#    elsif ($word =~ /\Ahasnt([_-].+)/  ) { return ("has$1")     }
#    elsif ($word =~ /\Ahavent([_-].+)/ ) { return ("have$1")    }
#
#    elsif ($word =~ /\Acan([_-].+)/    ) { return ("cant$1")    }
#    elsif ($word =~ /\Acant([_-].+)/   ) { return ("can$1")     }
#
#    elsif ($word =~ /\Aenabled([_-].+)/ ) { return ("disabled$1") }
#    elsif ($word =~ /\Adisabled([_-].+)/) { return ("enabled$1")  }
#    elsif ($word =~ /\Aenable([_-].+)/ )  { return ("disable$1")  }
#    elsif ($word =~ /\Adisable([_-].+)/)  { return ("enable$1")   }
#
#    elsif ($word =~ /\Aallowed([_-].+)/ )   { return ("disallowed$1") }
#    elsif ($word =~ /\Adisallowed([_-].+)/) { return ("allowed$1")    }
#    elsif ($word =~ /\Aallow([_-].+)/ )     { return ("disallow$1")   }
#    elsif ($word =~ /\Adisallow([_-].+)/)   { return ("allow$1")      }
#
#    elsif ($word =~ /\Ano[_-](.+)/     ) { return ($1)          }
#
#    else {
#        return ("no-$word", "no$word");
#    }
#}
#
#1;
#
#__END__
#
### Getopt/Long/Util.pm ###
#package Getopt::Long::Util;
#
#our $DATE = '2016-10-30'; 
#our $VERSION = '0.88'; 
#
#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
#                       gen_getopt_long_spec_from_getopt_std_spec
#               );
#
#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:
#
#* `is_arg` (if true, then option specification is the special `<>` for argument
#  callback)
#* `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;
#    return {is_arg=>1, dash_prefix=>'', opts=>[]}
#        if $optspec eq '<>';
#    $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 <pm: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";
#
#    return "argument" if $parse->{is_arg};
#
#    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*',
#            pos => 0,
#            cmdline_aliases => {f=>{}},
#        },
#        string => {
#            summary => 'String to be checked',
#            schema => 'buf*',
#        },
#        include_noexec => {
#            summary => 'Include scripts that do not have +x mode bit set',
#            schema  => 'bool*',
#            default => 1,
#        },
#    },
#    args_rels => {
#        'req_one' => ['filename', 'string'],
#    },
#};
#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 %extrameta;
#
#    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;
#        }
#
#
#
#        for (split /^/, $str) {
#            if (/^\s*(use|require)\s+(Getopt::Long(?:::Complete)?)(\s|;|$)/) {
#                $yesno = 1;
#                $extrameta{'func.module'} = $2;
#                last DETECT;
#            }
#        }
#
#        $reason = "Can't find any statement requiring Getopt::Long(?::Complete)? module";
#    } 
#
#    [200, "OK", $yesno, {"func.reason"=>$reason, %extrameta}];
#}
#
#$SPEC{gen_getopt_long_spec_from_getopt_std_spec} = {
#    v => 1.1,
#    summary => 'Generate Getopt::Long spec from Getopt::Std spec',
#    args => {
#        spec => {
#            summary => 'Getopt::Std spec string',
#            schema => 'str*',
#            req => 1,
#            pos => 0,
#        },
#        is_getopt => {
#            summary => 'Whether to assume spec is for getopt() or getopts()',
#            description => <<'_',
#
#By default spec is assumed to be for getopts() instead of getopt(). This means
#that for a spec like `abc:`, `a` and `b` don't take argument while `c` does. But
#if `is_getopt` is true, the meaning of `:` is reversed: `a` and `b` take
#arguments while `c` doesn't.
#
#_
#            schema => 'bool',
#        },
#    },
#    result_naked => 1,
#    result => {
#        schema => 'hash*',
#    },
#};
#sub gen_getopt_long_spec_from_getopt_std_spec {
#    my %args = @_;
#
#    my $is_getopt = $args{is_getopt};
#    my $spec = {};
#
#    while ($args{spec} =~ /(.)(:?)/g) {
#        $spec->{$1 . ($is_getopt ? ($2 ? "" : "=s") : ($2 ? "=s" : ""))} =
#            sub {};
#    }
#
#    $spec;
#}
#
#
#__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.72";
#
#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.72";
#
#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/Config.pm ###
#package HTTP::Config;
#
#use strict;
#use warnings;
#
#use URI;
#
#our $VERSION = "6.11";
#
#sub new {
#    my $class = shift;
#    return bless [], $class;
#}
#
#sub entries {
#    my $self = shift;
#    @$self;
#}
#
#sub empty {
#    my $self = shift;
#    not @$self;
#}
#
#sub add {
#    if (@_ == 2) {
#        my $self = shift;
#        push(@$self, shift);
#        return;
#    }
#    my($self, %spec) = @_;
#    push(@$self, \%spec);
#    return;
#}
#
#sub find2 {
#    my($self, %spec) = @_;
#    my @found;
#    my @rest;
# ITEM:
#    for my $item (@$self) {
#        for my $k (keys %spec) {
#            no warnings 'uninitialized';
#            if (!exists $item->{$k} || $spec{$k} ne $item->{$k}) {
#                push(@rest, $item);
#                next ITEM;
#            }
#        }
#        push(@found, $item);
#    }
#    return \@found unless wantarray;
#    return \@found, \@rest;
#}
#
#sub find {
#    my $self = shift;
#    my $f = $self->find2(@_);
#    return @$f if wantarray;
#    return $f->[0];
#}
#
#sub remove {
#    my($self, %spec) = @_;
#    my($removed, $rest) = $self->find2(%spec);
#    @$self = @$rest if @$removed;
#    return @$removed;
#}
#
#my %MATCH = (
#    m_scheme => sub {
#        my($v, $uri) = @_;
#        return $uri->_scheme eq $v;  
#    },
#    m_secure => sub {
#        my($v, $uri) = @_;
#        my $secure = $uri->can("secure") ? $uri->secure : $uri->_scheme eq "https";
#        return $secure == !!$v;
#    },
#    m_host_port => sub {
#        my($v, $uri) = @_;
#        return unless $uri->can("host_port");
#        return $uri->host_port eq $v, 7;
#    },
#    m_host => sub {
#        my($v, $uri) = @_;
#        return unless $uri->can("host");
#        return $uri->host eq $v, 6;
#    },
#    m_port => sub {
#        my($v, $uri) = @_;
#        return unless $uri->can("port");
#        return $uri->port eq $v;
#    },
#    m_domain => sub {
#        my($v, $uri) = @_;
#        return unless $uri->can("host");
#        my $h = $uri->host;
#        $h = "$h.local" unless $h =~ /\./;
#        $v = ".$v" unless $v =~ /^\./;
#        return length($v), 5 if substr($h, -length($v)) eq $v;
#        return 0;
#    },
#    m_path => sub {
#        my($v, $uri) = @_;
#        return unless $uri->can("path");
#        return $uri->path eq $v, 4;
#    },
#    m_path_prefix => sub {
#        my($v, $uri) = @_;
#        return unless $uri->can("path");
#        my $path = $uri->path;
#        my $len = length($v);
#        return $len, 3 if $path eq $v;
#        return 0 if length($path) <= $len;
#        $v .= "/" unless $v =~ m,/\z,,;
#        return $len, 3 if substr($path, 0, length($v)) eq $v;
#        return 0;
#    },
#    m_path_match => sub {
#        my($v, $uri) = @_;
#        return unless $uri->can("path");
#        return $uri->path =~ $v;
#    },
#    m_uri__ => sub {
#        my($v, $k, $uri) = @_;
#        return unless $uri->can($k);
#        return 1 unless defined $v;
#        return $uri->$k eq $v;
#    },
#    m_method => sub {
#        my($v, $uri, $request) = @_;
#        return $request && $request->method eq $v;
#    },
#    m_proxy => sub {
#        my($v, $uri, $request) = @_;
#        return $request && ($request->{proxy} || "") eq $v;
#    },
#    m_code => sub {
#        my($v, $uri, $request, $response) = @_;
#        $v =~ s/xx\z//;
#        return unless $response;
#        return length($v), 2 if substr($response->code, 0, length($v)) eq $v;
#    },
#    m_media_type => sub {  
#        my($v, $uri, $request, $response) = @_;
#        return unless $response;
#        return 1, 1 if $v eq "*/*";
#        my $ct = $response->content_type;
#        return 2, 1 if $v =~ s,/\*\z,, && $ct =~ m,^\Q$v\E/,;
#        return 3, 1 if $v eq "html" && $response->content_is_html;
#        return 4, 1 if $v eq "xhtml" && $response->content_is_xhtml;
#        return 10, 1 if $v eq $ct;
#        return 0;
#    },
#    m_header__ => sub {
#        my($v, $k, $uri, $request, $response) = @_;
#        return unless $request;
#        return 1 if $request->header($k) eq $v;
#        return 1 if $response && $response->header($k) eq $v;
#        return 0;
#    },
#    m_response_attr__ => sub {
#        my($v, $k, $uri, $request, $response) = @_;
#        return unless $response;
#        return 1 if !defined($v) && exists $response->{$k};
#        return 0 unless exists $response->{$k};
#        return 1 if $response->{$k} eq $v;
#        return 0;
#    },
#);
#
#sub matching {
#    my $self = shift;
#    if (@_ == 1) {
#        if ($_[0]->can("request")) {
#            unshift(@_, $_[0]->request);
#            unshift(@_, undef) unless defined $_[0];
#        }
#        unshift(@_, $_[0]->uri_canonical) if $_[0] && $_[0]->can("uri_canonical");
#    }
#    my($uri, $request, $response) = @_;
#    $uri = URI->new($uri) unless ref($uri);
#
#    my @m;
# ITEM:
#    for my $item (@$self) {
#        my $order;
#        for my $ikey (keys %$item) {
#            my $mkey = $ikey;
#            my $k;
#            $k = $1 if $mkey =~ s/__(.*)/__/;
#            if (my $m = $MATCH{$mkey}) {
#                my($c, $o);
#                my @arg = (
#                    defined($k) ? $k : (),
#                    $uri, $request, $response
#                );
#                my $v = $item->{$ikey};
#                $v = [$v] unless ref($v) eq "ARRAY";
#                for (@$v) {
#                    ($c, $o) = $m->($_, @arg);
#                    last if $c;
#                }
#                next ITEM unless $c;
#                $order->[$o || 0] += $c;
#            }
#        }
#        $order->[7] ||= 0;
#        $item->{_order} = join(".", reverse map sprintf("%03d", $_ || 0), @$order);
#        push(@m, $item);
#    }
#    @m = sort { $b->{_order} cmp $a->{_order} } @m;
#    delete $_->{_order} for @m;
#    return @m if wantarray;
#    return $m[0];
#}
#
#sub add_item {
#    my $self = shift;
#    my $item = shift;
#    return $self->add(item => $item, @_);
#}
#
#sub remove_items {
#    my $self = shift;
#    return map $_->{item}, $self->remove(@_);
#}
#
#sub matching_items {
#    my $self = shift;
#    return map $_->{item}, $self->matching(@_);
#}
#
#1;
#
#__END__
#
### HTTP/Cookies.pm ###
#package HTTP::Cookies;
#
#use strict;
#use HTTP::Date qw(str2time parse_date time2str);
#use HTTP::Headers::Util qw(_split_header_words join_header_words);
#
#use vars qw($VERSION $EPOCH_OFFSET);
#$VERSION = "6.01";
#
#require HTTP::Cookies::Netscape;
#
#$EPOCH_OFFSET = 0;  
#if ($^O eq "MacOS") {
#    require Time::Local;
#    $EPOCH_OFFSET = Time::Local::timelocal(0,0,0,1,0,70);
#}
#
#
#sub new
#{
#    my $class = shift;
#    my $self = bless {
#	COOKIES => {},
#    }, $class;
#    my %cnf = @_;
#    for (keys %cnf) {
#	$self->{lc($_)} = $cnf{$_};
#    }
#    $self->load;
#    $self;
#}
#
#
#sub add_cookie_header
#{
#    my $self = shift;
#    my $request = shift || return;
#    my $url = $request->uri;
#    my $scheme = $url->scheme;
#    unless ($scheme =~ /^https?\z/) {
#	return;
#    }
#
#    my $domain = _host($request, $url);
#    $domain = "$domain.local" unless $domain =~ /\./;
#    my $secure_request = ($scheme eq "https");
#    my $req_path = _url_path($url);
#    my $req_port = $url->port;
#    my $now = time();
#    _normalize_path($req_path) if $req_path =~ /%/;
#
#    my @cval;    
#    my $set_ver;
#    my $netscape_only = 0; 
#
#    while ($domain =~ /\./) {
#	my $cookies = $self->{COOKIES}{$domain};
#	next unless $cookies;
#	if ($self->{delayload} && defined($cookies->{'//+delayload'})) {
#	    my $cookie_data = $cookies->{'//+delayload'}{'cookie'};
#	    delete $self->{COOKIES}{$domain};
#	    $self->load_cookie($cookie_data->[1]);
#	    $cookies = $self->{COOKIES}{$domain};
#	    next unless $cookies;  
#	}
#
#	my $path;
#	for $path (sort {length($b) <=> length($a) } keys %$cookies) {
#	    if (index($req_path, $path) != 0) {
#		next;
#	    }
#
#	    my($key,$array);
#	    while (($key,$array) = each %{$cookies->{$path}}) {
#		my($version,$val,$port,$path_spec,$secure,$expires) = @$array;
#		if ($secure && !$secure_request) {
#		    next;
#		}
#		if ($expires && $expires < $now) {
#		    next;
#		}
#		if ($port) {
#		    my $found;
#		    if ($port =~ s/^_//) {
#			$found++ if $port eq $req_port;
#			$port = "";
#		    }
#		    else {
#			my $p;
#			for $p (split(/,/, $port)) {
#			    $found++, last if $p eq $req_port;
#			}
#		    }
#		    unless ($found) {
#			next;
#		    }
#		}
#		if ($version > 0 && $netscape_only) {
#		    next;
#		}
#
#		if (!$set_ver++) {
#		    if ($version >= 1) {
#			push(@cval, "\$Version=$version");
#		    }
#		    elsif (!$self->{hide_cookie2}) {
#			$request->header(Cookie2 => '$Version="1"');
#		    }
#		}
#
#		if ($val =~ /\W/ && $version) {
#		    $val =~ s/([\\\"])/\\$1/g;
#		    $val = qq("$val");
#		}
#
#		push(@cval, "$key=$val");
#		if ($version >= 1) {
#		    push(@cval, qq(\$Path="$path"))     if $path_spec;
#		    push(@cval, qq(\$Domain="$domain")) if $domain =~ /^\./;
#		    if (defined $port) {
#			my $p = '$Port';
#			$p .= qq(="$port") if length $port;
#			push(@cval, $p);
#		    }
#		}
#
#	    }
#        }
#
#    } continue {
#
#	if ($domain =~ s/^\.+//) {
#	    $netscape_only = 1;
#	}
#	else {
#	    $domain =~ s/[^.]*//;
#	    $netscape_only = 0;
#	}
#    }
#
#    if (@cval) {
#	if (my $old = $request->header("Cookie")) {
#	    unshift(@cval, $old);
#	}
#	$request->header(Cookie => join("; ", @cval));
#    }
#
#    $request;
#}
#
#
#sub extract_cookies
#{
#    my $self = shift;
#    my $response = shift || return;
#
#    my @set = _split_header_words($response->_header("Set-Cookie2"));
#    my @ns_set = $response->_header("Set-Cookie");
#
#    return $response unless @set || @ns_set;  
#
#    my $request = $response->request;
#    my $url = $request->uri;
#    my $req_host = _host($request, $url);
#    $req_host = "$req_host.local" unless $req_host =~ /\./;
#    my $req_port = $url->port;
#    my $req_path = _url_path($url);
#    _normalize_path($req_path) if $req_path =~ /%/;
#
#    if (@ns_set) {
#	my $now = time();
#
#	my %in_set2;
#	for (@set) {
#	    $in_set2{$_->[0]}++;
#	}
#
#	my $set;
#	for $set (@ns_set) {
#            $set =~ s/^\s+//;
#	    my @cur;
#	    my $param;
#	    my $expires;
#	    my $first_param = 1;
#	    for $param (split(/;\s*/, $set)) {
#                next unless length($param);
#		my($k,$v) = split(/\s*=\s*/, $param, 2);
#		if (defined $v) {
#		    $v =~ s/\s+$//;
#		}
#		else {
#		    $k =~ s/\s+$//;
#		}
#		if (!$first_param && lc($k) eq "expires") {
#		    my $etime = str2time($v);
#		    if (defined $etime) {
#			push(@cur, "Max-Age" => $etime - $now);
#			$expires++;
#		    }
#		    else {
#			my($year, $mon, $day, $hour, $min, $sec, $tz) = parse_date($v);
#			if ($year) {
#			    my $thisyear = (gmtime)[5] + 1900;
#			    if ($year < $thisyear) {
#				push(@cur, "Max-Age" => -1);  
#				$expires++;
#			    }
#			    elsif ($year >= $thisyear + 10) {
#				push(@cur, "Max-Age" => 10 * 365 * 24 * 60 * 60);
#				$expires++;
#			    }
#			}
#		    }
#		}
#                elsif (!$first_param && lc($k) =~ /^(?:version|discard|ns-cookie)/) {
#                }
#		else {
#		    push(@cur, $k => $v);
#		}
#		$first_param = 0;
#	    }
#            next unless @cur;
#	    next if $in_set2{$cur[0]};
#
#	    push(@cur, "Discard" => undef) unless $expires;
#	    push(@cur, "Version" => 0);
#	    push(@cur, "ns-cookie" => 1);
#	    push(@set, \@cur);
#	}
#    }
#
#  SET_COOKIE:
#    for my $set (@set) {
#	next unless @$set >= 2;
#
#	my $key = shift @$set;
#	my $val = shift @$set;
#
#	my %hash;
#	while (@$set) {
#	    my $k = shift @$set;
#	    my $v = shift @$set;
#	    my $lc = lc($k);
#	    $k = $lc if $lc =~ /^(?:discard|domain|max-age|
#                                    path|port|secure|version)$/x;
#	    if ($k eq "discard" || $k eq "secure") {
#		$v = 1 unless defined $v;
#	    }
#	    next if exists $hash{$k};  
#	    $hash{$k} = $v;
#	};
#
#	my %orig_hash = %hash;
#	my $version   = delete $hash{version};
#	$version = 1 unless defined($version);
#	my $discard   = delete $hash{discard};
#	my $secure    = delete $hash{secure};
#	my $maxage    = delete $hash{'max-age'};
#	my $ns_cookie = delete $hash{'ns-cookie'};
#
#	my $domain  = delete $hash{domain};
#	$domain = lc($domain) if defined $domain;
#	if (defined($domain)
#	    && $domain ne $req_host && $domain ne ".$req_host") {
#	    if ($domain !~ /\./ && $domain ne "local") {
#		next SET_COOKIE;
#	    }
#	    $domain = ".$domain" unless $domain =~ /^\./;
#	    if ($domain =~ /\.\d+$/) {
#		next SET_COOKIE;
#	    }
#	    my $len = length($domain);
#	    unless (substr($req_host, -$len) eq $domain) {
#		next SET_COOKIE;
#	    }
#	    my $hostpre = substr($req_host, 0, length($req_host) - $len);
#	    if ($hostpre =~ /\./ && !$ns_cookie) {
#		next SET_COOKIE;
#	    }
#	}
#	else {
#	    $domain = $req_host;
#	}
#
#	my $path = delete $hash{path};
#	my $path_spec;
#	if (defined $path && $path ne '') {
#	    $path_spec++;
#	    _normalize_path($path) if $path =~ /%/;
#	    if (!$ns_cookie &&
#                substr($req_path, 0, length($path)) ne $path) {
#		next SET_COOKIE;
#	    }
#	}
#	else {
#	    $path = $req_path;
#	    $path =~ s,/[^/]*$,,;
#	    $path = "/" unless length($path);
#	}
#
#	my $port;
#	if (exists $hash{port}) {
#	    $port = delete $hash{port};
#	    if (defined $port) {
#		$port =~ s/\s+//g;
#		my $found;
#		for my $p (split(/,/, $port)) {
#		    unless ($p =~ /^\d+$/) {
#			next SET_COOKIE;
#		    }
#		    $found++ if $p eq $req_port;
#		}
#		unless ($found) {
#		    next SET_COOKIE;
#		}
#	    }
#	    else {
#		$port = "_$req_port";
#	    }
#	}
#	$self->set_cookie($version,$key,$val,$path,$domain,$port,$path_spec,$secure,$maxage,$discard, \%hash)
#	    if $self->set_cookie_ok(\%orig_hash);
#    }
#
#    $response;
#}
#
#sub set_cookie_ok
#{
#    1;
#}
#
#
#sub set_cookie
#{
#    my $self = shift;
#    my($version,
#       $key, $val, $path, $domain, $port,
#       $path_spec, $secure, $maxage, $discard, $rest) = @_;
#
#    return $self if !defined($path) || $path !~ m,^/, ||
#	            !defined($key)  || $key  =~ m,^\$,;
#
#    if (defined $port) {
#	return $self unless $port =~ /^_?\d+(?:,\d+)*$/;
#    }
#
#    my $expires;
#    if (defined $maxage) {
#	if ($maxage <= 0) {
#	    delete $self->{COOKIES}{$domain}{$path}{$key};
#	    return $self;
#	}
#	$expires = time() + $maxage;
#    }
#    $version = 0 unless defined $version;
#
#    my @array = ($version, $val,$port,
#		 $path_spec,
#		 $secure, $expires, $discard);
#    push(@array, {%$rest}) if defined($rest) && %$rest;
#    pop(@array) while !defined $array[-1];
#
#    $self->{COOKIES}{$domain}{$path}{$key} = \@array;
#    $self;
#}
#
#
#sub save
#{
#    my $self = shift;
#    my $file = shift || $self->{'file'} || return;
#    local(*FILE);
#    open(FILE, ">$file") or die "Can't open $file: $!";
#    print FILE "#LWP-Cookies-1.0\n";
#    print FILE $self->as_string(!$self->{ignore_discard});
#    close(FILE);
#    1;
#}
#
#
#sub load
#{
#    my $self = shift;
#    my $file = shift || $self->{'file'} || return;
#    local(*FILE, $_);
#    local $/ = "\n";  
#    open(FILE, $file) or return;
#    my $magic = <FILE>;
#    unless ($magic =~ /^\#LWP-Cookies-(\d+\.\d+)/) {
#	warn "$file does not seem to contain cookies";
#	return;
#    }
#    while (<FILE>) {
#	next unless s/^Set-Cookie3:\s*//;
#	chomp;
#	my $cookie;
#	for $cookie (_split_header_words($_)) {
#	    my($key,$val) = splice(@$cookie, 0, 2);
#	    my %hash;
#	    while (@$cookie) {
#		my $k = shift @$cookie;
#		my $v = shift @$cookie;
#		$hash{$k} = $v;
#	    }
#	    my $version   = delete $hash{version};
#	    my $path      = delete $hash{path};
#	    my $domain    = delete $hash{domain};
#	    my $port      = delete $hash{port};
#	    my $expires   = str2time(delete $hash{expires});
#
#	    my $path_spec = exists $hash{path_spec}; delete $hash{path_spec};
#	    my $secure    = exists $hash{secure};    delete $hash{secure};
#	    my $discard   = exists $hash{discard};   delete $hash{discard};
#
#	    my @array =	($version,$val,$port,
#			 $path_spec,$secure,$expires,$discard);
#	    push(@array, \%hash) if %hash;
#	    $self->{COOKIES}{$domain}{$path}{$key} = \@array;
#	}
#    }
#    close(FILE);
#    1;
#}
#
#
#sub revert
#{
#    my $self = shift;
#    $self->clear->load;
#    $self;
#}
#
#
#sub clear
#{
#    my $self = shift;
#    if (@_ == 0) {
#	$self->{COOKIES} = {};
#    }
#    elsif (@_ == 1) {
#	delete $self->{COOKIES}{$_[0]};
#    }
#    elsif (@_ == 2) {
#	delete $self->{COOKIES}{$_[0]}{$_[1]};
#    }
#    elsif (@_ == 3) {
#	delete $self->{COOKIES}{$_[0]}{$_[1]}{$_[2]};
#    }
#    else {
#	require Carp;
#        Carp::carp('Usage: $c->clear([domain [,path [,key]]])');
#    }
#    $self;
#}
#
#
#sub clear_temporary_cookies
#{
#    my($self) = @_;
#
#    $self->scan(sub {
#        if($_[9] or        
#           not $_[8]) {    
#            $_[8] = -1;            
#            $self->set_cookie(@_); 
#        }
#      });
#}
#
#
#sub DESTROY
#{
#    my $self = shift;
#    local($., $@, $!, $^E, $?);
#    $self->save if $self->{'autosave'};
#}
#
#
#sub scan
#{
#    my($self, $cb) = @_;
#    my($domain,$path,$key);
#    for $domain (sort keys %{$self->{COOKIES}}) {
#	for $path (sort keys %{$self->{COOKIES}{$domain}}) {
#	    for $key (sort keys %{$self->{COOKIES}{$domain}{$path}}) {
#		my($version,$val,$port,$path_spec,
#		   $secure,$expires,$discard,$rest) =
#		       @{$self->{COOKIES}{$domain}{$path}{$key}};
#		$rest = {} unless defined($rest);
#		&$cb($version,$key,$val,$path,$domain,$port,
#		     $path_spec,$secure,$expires,$discard,$rest);
#	    }
#	}
#    }
#}
#
#
#sub as_string
#{
#    my($self, $skip_discard) = @_;
#    my @res;
#    $self->scan(sub {
#	my($version,$key,$val,$path,$domain,$port,
#	   $path_spec,$secure,$expires,$discard,$rest) = @_;
#	return if $discard && $skip_discard;
#	my @h = ($key, $val);
#	push(@h, "path", $path);
#	push(@h, "domain" => $domain);
#	push(@h, "port" => $port) if defined $port;
#	push(@h, "path_spec" => undef) if $path_spec;
#	push(@h, "secure" => undef) if $secure;
#	push(@h, "expires" => HTTP::Date::time2isoz($expires)) if $expires;
#	push(@h, "discard" => undef) if $discard;
#	my $k;
#	for $k (sort keys %$rest) {
#	    push(@h, $k, $rest->{$k});
#	}
#	push(@h, "version" => $version);
#	push(@res, "Set-Cookie3: " . join_header_words(\@h));
#    });
#    join("\n", @res, "");
#}
#
#sub _host
#{
#    my($request, $url) = @_;
#    if (my $h = $request->header("Host")) {
#	$h =~ s/:\d+$//;  
#	return lc($h);
#    }
#    return lc($url->host);
#}
#
#sub _url_path
#{
#    my $url = shift;
#    my $path;
#    if($url->can('epath')) {
#       $path = $url->epath;    
#    }
#    else {
#       $path = $url->path;           
#    }
#    $path = "/" unless length $path;
#    $path;
#}
#
#sub _normalize_path  
#{
#    my $x;
#    $_[0] =~ s/%([0-9a-fA-F][0-9a-fA-F])/
#	         $x = uc($1);
#                 $x eq "2F" || $x eq "25" ? "%$x" :
#                                            pack("C", hex($x));
#              /eg;
#    $_[0] =~ s/([\0-\x20\x7f-\xff])/sprintf("%%%02X",ord($1))/eg;
#}
#
#1;
#
#__END__
#
### HTTP/Cookies/Microsoft.pm ###
#package HTTP::Cookies::Microsoft;
#
#use strict;
#
#use vars qw(@ISA $VERSION);
#
#$VERSION = "6.00";
#
#require HTTP::Cookies;
#@ISA=qw(HTTP::Cookies);
#
#sub load_cookies_from_file
#{
#	my ($file) = @_;
#	my @cookies;
#	my ($key, $value, $domain_path, $flags, $lo_expire, $hi_expire);
#	my ($lo_create, $hi_create, $sep);
#
#	open(COOKIES, $file) || return;
#
#	while ($key = <COOKIES>)
#	{
#		chomp($key);
#		chomp($value     = <COOKIES>);
#		chomp($domain_path= <COOKIES>);
#		chomp($flags     = <COOKIES>);		
#		chomp($lo_expire = <COOKIES>);
#		chomp($hi_expire = <COOKIES>);
#		chomp($lo_create = <COOKIES>);
#		chomp($hi_create = <COOKIES>);
#		chomp($sep       = <COOKIES>);
#
#		if (!defined($key) || !defined($value) || !defined($domain_path) ||
#			!defined($flags) || !defined($hi_expire) || !defined($lo_expire) ||
#			!defined($hi_create) || !defined($lo_create) || !defined($sep) ||
#			($sep ne '*'))
#		{
#			last;
#		}
#
#		if ($domain_path =~ /^([^\/]+)(\/.*)$/)
#		{
#			my $domain = $1;
#			my $path = $2;
#
#			push(@cookies, {KEY => $key, VALUE => $value, DOMAIN => $domain,
#					PATH => $path, FLAGS =>$flags, HIXP =>$hi_expire,
#					LOXP => $lo_expire, HICREATE => $hi_create,
#					LOCREATE => $lo_create});
#		}
#	}
#
#	return \@cookies;
#}
#
#sub get_user_name
#{
#	use Win32;
#	use locale;
#	my $user = lc(Win32::LoginName());
#
#	return $user;
#}
#
#sub epoch_time_offset_from_win32_filetime
#{
#	my ($high, $low) = @_;
#
#	
#	my $filetime_low32_1970 = 0xd53e8000;
#	my $filetime_high32_1970 = 0x019db1de;
#
#
#	if (($high < $filetime_high32_1970) ||
#	    (($high == $filetime_high32_1970) && ($low < $filetime_low32_1970)))
#    	{
#		return 0;
#	}
#
#	my $date1970 = (($filetime_high32_1970 * 0x10000) * 0x10000) + $filetime_low32_1970;
#	my $time = (($high * 0x10000) * 0x10000) + $low;
#
#	$time -= $date1970;
#	$time /= 10000000;
#
#	return $time;
#}
#
#sub load_cookie
#{
#	my($self, $file) = @_;
#        my $now = time() - $HTTP::Cookies::EPOCH_OFFSET;
#	my $cookie_data;
#
#        if (-f $file)
#        {
#		$cookie_data = load_cookies_from_file($file);
#
#		foreach my $cookie (@{$cookie_data})
#		{
#			my $secure = ($cookie->{FLAGS} & 1) != 0;
#			my $expires = epoch_time_offset_from_win32_filetime($cookie->{HIXP}, $cookie->{LOXP});
#
#			$self->set_cookie(undef, $cookie->{KEY}, $cookie->{VALUE}, 
#					  $cookie->{PATH}, $cookie->{DOMAIN}, undef,
#					  0, $secure, $expires-$now, 0);
#		}
#	}
#}
#
#sub load
#{
#	my($self, $cookie_index) = @_;
#	my $now = time() - $HTTP::Cookies::EPOCH_OFFSET;
#	my $cookie_dir = '';
#	my $delay_load = (defined($self->{'delayload'}) && $self->{'delayload'});
#	my $user_name = get_user_name();
#	my $data;
#
#	$cookie_index ||= $self->{'file'} || return;
#	if ($cookie_index =~ /[\\\/][^\\\/]+$/)
#	{
#		$cookie_dir = $` . "\\";
#	}
#
#	local(*INDEX, $_);
#
#	open(INDEX, $cookie_index) || return;
#	binmode(INDEX);
#	if (256 != read(INDEX, $data, 256))
#	{
#		warn "$cookie_index file is not large enough";
#		close(INDEX);
#		return;
#	}
#
#	my ($sig, $size) = unpack('a32 V', $data);
#	
#	if (($sig !~ /^Client UrlCache MMF Ver 5\.2/) || 
#		(0x4000 != $size))
#	{
#		warn "$cookie_index ['$sig' $size] does not seem to contain cookies";
#		close(INDEX);
#		return;
#	}
#
#	if (0 == seek(INDEX, $size, 0)) 
#	{
#		close(INDEX);
#		return;
#	}
#
#	while (256 == read(INDEX, $data, 256))
#	{
#		($sig, $size) = unpack('a4 V', $data);
#
#		if ('URL ' ne $sig)
#		{
#			if (($sig eq 'HASH') || ($sig eq 'LEAK'))
#			{
#				if (($size > 0) && ($size != 2))
#				{
#				    if (0 == seek(INDEX, ($size-2)*0x80, 1))
#				    {
#					    last;
#				    }
#				}
#			}
#			next;
#		}
#
#		if ($size > 2)
#		{
#			my $more_data = ($size-2)*0x80;
#
#			if ($more_data != read(INDEX, $data, $more_data, 256))
#			{
#				last;
#			}
#		}
#
#                (my $user_name2 = $user_name) =~ s/ /_/g;
#		if ($data =~ /Cookie\:\Q$user_name\E\@([\x21-\xFF]+).*?((?:\Q$user_name\E|\Q$user_name2\E)\@[\x21-\xFF]+\.txt)/)
#		{
#			my $cookie_file = $cookie_dir . $2; 
#
#			if (!$delay_load)
#			{
#				$self->load_cookie($cookie_file);
#			}
#			else
#			{
#				my $domain = $1;
#
#				if ($domain =~ m{[\\/]})
#				{
#					$domain = $`;
#				}
#
#				$self->set_cookie(undef, 'cookie', $cookie_file,
#						      '//+delayload', $domain, undef,
#						      0, 0, $now+86400, 0);
#			}
#		}
#	}
#
#	close(INDEX);
#
#	1;
#}
#
#1;
#
#__END__
#
#
### HTTP/Cookies/Netscape.pm ###
#package HTTP::Cookies::Netscape;
#
#use strict;
#use vars qw(@ISA $VERSION);
#
#$VERSION = "6.00";
#
#require HTTP::Cookies;
#@ISA=qw(HTTP::Cookies);
#
#sub load
#{
#    my($self, $file) = @_;
#    $file ||= $self->{'file'} || return;
#    local(*FILE, $_);
#    local $/ = "\n";  
#    my @cookies;
#    open(FILE, $file) || return;
#    my $magic = <FILE>;
#    unless ($magic =~ /^\#(?: Netscape)? HTTP Cookie File/) {
#	warn "$file does not look like a netscape cookies file" if $^W;
#	close(FILE);
#	return;
#    }
#    my $now = time() - $HTTP::Cookies::EPOCH_OFFSET;
#    while (<FILE>) {
#	next if /^\s*\#/;
#	next if /^\s*$/;
#	tr/\n\r//d;
#	my($domain,$bool1,$path,$secure, $expires,$key,$val) = split(/\t/, $_);
#	$secure = ($secure eq "TRUE");
#	$self->set_cookie(undef,$key,$val,$path,$domain,undef,
#			  0,$secure,$expires-$now, 0);
#    }
#    close(FILE);
#    1;
#}
#
#sub save
#{
#    my($self, $file) = @_;
#    $file ||= $self->{'file'} || return;
#    local(*FILE, $_);
#    open(FILE, ">$file") || return;
#
#    print FILE <<EOT;
## Netscape HTTP Cookie File
## http://www.netscape.com/newsref/std/cookie_spec.html
## This is a generated file!  Do not edit.
#
#EOT
#
#    my $now = time - $HTTP::Cookies::EPOCH_OFFSET;
#    $self->scan(sub {
#	my($version,$key,$val,$path,$domain,$port,
#	   $path_spec,$secure,$expires,$discard,$rest) = @_;
#	return if $discard && !$self->{ignore_discard};
#	$expires = $expires ? $expires - $HTTP::Cookies::EPOCH_OFFSET : 0;
#	return if $now > $expires;
#	$secure = $secure ? "TRUE" : "FALSE";
#	my $bool = $domain =~ /^\./ ? "TRUE" : "FALSE";
#	print FILE join("\t", $domain, $bool, $path, $secure, $expires, $key, $val), "\n";
#    });
#    close(FILE);
#    1;
#}
#
#1;
#__END__
#
### HTTP/Daemon.pm ###
#package HTTP::Daemon;
#
#use strict;
#use vars qw($VERSION @ISA $PROTO $DEBUG);
#
#$VERSION = "6.01";
#
#use IO::Socket qw(AF_INET INADDR_ANY INADDR_LOOPBACK inet_ntoa);
#@ISA=qw(IO::Socket::INET);
#
#$PROTO = "HTTP/1.1";
#
#
#sub new
#{
#    my($class, %args) = @_;
#    $args{Listen} ||= 5;
#    $args{Proto}  ||= 'tcp';
#    return $class->SUPER::new(%args);
#}
#
#
#sub accept
#{
#    my $self = shift;
#    my $pkg = shift || "HTTP::Daemon::ClientConn";
#    my ($sock, $peer) = $self->SUPER::accept($pkg);
#    if ($sock) {
#        ${*$sock}{'httpd_daemon'} = $self;
#        return wantarray ? ($sock, $peer) : $sock;
#    }
#    else {
#        return;
#    }
#}
#
#
#sub url
#{
#    my $self = shift;
#    my $url = $self->_default_scheme . "://";
#    my $addr = $self->sockaddr;
#    if (!$addr || $addr eq INADDR_ANY) {
# 	require Sys::Hostname;
# 	$url .= lc Sys::Hostname::hostname();
#    }
#    elsif ($addr eq INADDR_LOOPBACK) {
#	$url .= inet_ntoa($addr);
#    }
#    else {
#	$url .= gethostbyaddr($addr, AF_INET) || inet_ntoa($addr);
#    }
#    my $port = $self->sockport;
#    $url .= ":$port" if $port != $self->_default_port;
#    $url .= "/";
#    $url;
#}
#
#
#sub _default_port {
#    80;
#}
#
#
#sub _default_scheme {
#    "http";
#}
#
#
#sub product_tokens
#{
#    "libwww-perl-daemon/$HTTP::Daemon::VERSION";
#}
#
#
#
#package HTTP::Daemon::ClientConn;
#
#use vars qw(@ISA $DEBUG);
#use IO::Socket ();
#@ISA=qw(IO::Socket::INET);
#*DEBUG = \$HTTP::Daemon::DEBUG;
#
#use HTTP::Request  ();
#use HTTP::Response ();
#use HTTP::Status;
#use HTTP::Date qw(time2str);
#use LWP::MediaTypes qw(guess_media_type);
#use Carp ();
#
#my $CRLF = "\015\012";   
#my $HTTP_1_0 = _http_version("HTTP/1.0");
#my $HTTP_1_1 = _http_version("HTTP/1.1");
#
#
#sub get_request
#{
#    my($self, $only_headers) = @_;
#    if (${*$self}{'httpd_nomore'}) {
#        $self->reason("No more requests from this connection");
#	return;
#    }
#
#    $self->reason("");
#    my $buf = ${*$self}{'httpd_rbuf'};
#    $buf = "" unless defined $buf;
#
#    my $timeout = $ {*$self}{'io_socket_timeout'};
#    my $fdset = "";
#    vec($fdset, $self->fileno, 1) = 1;
#    local($_);
#
#  READ_HEADER:
#    while (1) {
#	$buf =~ s/^(?:\015?\012)+//;  
#	if ($buf =~ /\012/) {  
#	    if ($buf =~ /^\w+[^\012]+HTTP\/\d+\.\d+\015?\012/) {
#		if ($buf =~ /\015?\012\015?\012/) {
#		    last READ_HEADER;  
#		}
#		elsif (length($buf) > 16*1024) {
#		    $self->send_error(413); 
#		    $self->reason("Very long header");
#		    return;
#		}
#	    }
#	    else {
#		last READ_HEADER;  
#	    }
#	}
#	elsif (length($buf) > 16*1024) {
#	    $self->send_error(414); 
#	    $self->reason("Very long first line");
#	    return;
#	}
#	print STDERR "Need more data for complete header\n" if $DEBUG;
#	return unless $self->_need_more($buf, $timeout, $fdset);
#    }
#    if ($buf !~ s/^(\S+)[ \t]+(\S+)(?:[ \t]+(HTTP\/\d+\.\d+))?[^\012]*\012//) {
#	${*$self}{'httpd_client_proto'} = _http_version("HTTP/1.0");
#	$self->send_error(400);  
#	$self->reason("Bad request line: $buf");
#	return;
#    }
#    my $method = $1;
#    my $uri = $2;
#    my $proto = $3 || "HTTP/0.9";
#    $uri = "http://$uri" if $method eq "CONNECT";
#    $uri = $HTTP::URI_CLASS->new($uri, $self->daemon->url);
#    my $r = HTTP::Request->new($method, $uri);
#    $r->protocol($proto);
#    ${*$self}{'httpd_client_proto'} = $proto = _http_version($proto);
#    ${*$self}{'httpd_head'} = ($method eq "HEAD");
#
#    if ($proto >= $HTTP_1_0) {
#	my($key, $val);
#      HEADER:
#	while ($buf =~ s/^([^\012]*)\012//) {
#	    $_ = $1;
#	    s/\015$//;
#	    if (/^([^:\s]+)\s*:\s*(.*)/) {
#		$r->push_header($key, $val) if $key;
#		($key, $val) = ($1, $2);
#	    }
#	    elsif (/^\s+(.*)/) {
#		$val .= " $1";
#	    }
#	    else {
#		last HEADER;
#	    }
#	}
#	$r->push_header($key, $val) if $key;
#    }
#
#    my $conn = $r->header('Connection');
#    if ($proto >= $HTTP_1_1) {
#	${*$self}{'httpd_nomore'}++ if $conn && lc($conn) =~ /\bclose\b/;
#    }
#    else {
#	${*$self}{'httpd_nomore'}++ unless $conn &&
#                                           lc($conn) =~ /\bkeep-alive\b/;
#    }
#
#    if ($only_headers) {
#	${*$self}{'httpd_rbuf'} = $buf;
#        return $r;
#    }
#
#    my $te  = $r->header('Transfer-Encoding');
#    my $ct  = $r->header('Content-Type');
#    my $len = $r->header('Content-Length');
#
#    for my $e ( $r->header('Expect') ) {
#        if( lc($e) eq '100-continue' ) {
#            $self->send_status_line(100);
#            $self->send_crlf;
#        }
#        else {
#            $self->send_error(417);
#            $self->reason("Unsupported Expect header value");
#            return;
#        }
#    }
#
#    if ($te && lc($te) eq 'chunked') {
#	my $body = "";
#      CHUNK:
#	while (1) {
#	    print STDERR "Chunked\n" if $DEBUG;
#	    if ($buf =~ s/^([^\012]*)\012//) {
#		my $chunk_head = $1;
#		unless ($chunk_head =~ /^([0-9A-Fa-f]+)/) {
#		    $self->send_error(400);
#		    $self->reason("Bad chunk header $chunk_head");
#		    return;
#		}
#		my $size = hex($1);
#		last CHUNK if $size == 0;
#
#		my $missing = $size - length($buf) + 2; 
#		while ($missing > 0) {
#		    print STDERR "Need $missing more bytes\n" if $DEBUG;
#		    my $n = $self->_need_more($buf, $timeout, $fdset);
#		    return unless $n;
#		    $missing -= $n;
#		}
#		$body .= substr($buf, 0, $size);
#		substr($buf, 0, $size+2) = '';
#
#	    }
#	    else {
#		return unless $self->_need_more($buf, $timeout, $fdset);
#	    }
#	}
#	$r->content($body);
#
#	$r->remove_header('Transfer-Encoding');
#	$r->header('Content-Length', length($body));
#
#	my($key, $val);
#      FOOTER:
#	while (1) {
#	    if ($buf !~ /\012/) {
#		return unless $self->_need_more($buf, $timeout, $fdset);
#	    }
#	    else {
#		$buf =~ s/^([^\012]*)\012//;
#		$_ = $1;
#		s/\015$//;
#		if (/^([\w\-]+)\s*:\s*(.*)/) {
#		    $r->push_header($key, $val) if $key;
#		    ($key, $val) = ($1, $2);
#		}
#		elsif (/^\s+(.*)/) {
#		    $val .= " $1";
#		}
#		elsif (!length) {
#		    last FOOTER;
#		}
#		else {
#		    $self->reason("Bad footer syntax");
#		    return;
#		}
#	    }
#	}
#	$r->push_header($key, $val) if $key;
#
#    }
#    elsif ($te) {
#	$self->send_error(501); 	
#	$self->reason("Unknown transfer encoding '$te'");
#	return;
#
#    }
#    elsif ($len) {
#	my $missing = $len - length($buf);
#	while ($missing > 0) {
#	    print "Need $missing more bytes of content\n" if $DEBUG;
#	    my $n = $self->_need_more($buf, $timeout, $fdset);
#	    return unless $n;
#	    $missing -= $n;
#	}
#	if (length($buf) > $len) {
#	    $r->content(substr($buf,0,$len));
#	    substr($buf, 0, $len) = '';
#	}
#	else {
#	    $r->content($buf);
#	    $buf='';
#	}
#    }
#    elsif ($ct && $ct =~ m/^multipart\/\w+\s*;.*boundary\s*=\s*("?)(\w+)\1/i) {
#	my $boundary = "$CRLF--$2--";
#	my $index;
#	while (1) {
#	    $index = index($buf, $boundary);
#	    last if $index >= 0;
#	    return unless $self->_need_more($buf, $timeout, $fdset);
#	}
#	$index += length($boundary);
#	$r->content(substr($buf, 0, $index));
#	substr($buf, 0, $index) = '';
#
#    }
#    ${*$self}{'httpd_rbuf'} = $buf;
#
#    $r;
#}
#
#
#sub _need_more
#{
#    my $self = shift;
#    if ($_[1]) {
#	my($timeout, $fdset) = @_[1,2];
#	print STDERR "select(,,,$timeout)\n" if $DEBUG;
#	my $n = select($fdset,undef,undef,$timeout);
#	unless ($n) {
#	    $self->reason(defined($n) ? "Timeout" : "select: $!");
#	    return;
#	}
#    }
#    print STDERR "sysread()\n" if $DEBUG;
#    my $n = sysread($self, $_[0], 2048, length($_[0]));
#    $self->reason(defined($n) ? "Client closed" : "sysread: $!") unless $n;
#    $n;
#}
#
#
#sub read_buffer
#{
#    my $self = shift;
#    my $old = ${*$self}{'httpd_rbuf'};
#    if (@_) {
#	${*$self}{'httpd_rbuf'} = shift;
#    }
#    $old;
#}
#
#
#sub reason
#{
#    my $self = shift;
#    my $old = ${*$self}{'httpd_reason'};
#    if (@_) {
#        ${*$self}{'httpd_reason'} = shift;
#    }
#    $old;
#}
#
#
#sub proto_ge
#{
#    my $self = shift;
#    ${*$self}{'httpd_client_proto'} >= _http_version(shift);
#}
#
#
#sub _http_version
#{
#    local($_) = shift;
#    return 0 unless m,^(?:HTTP/)?(\d+)\.(\d+)$,i;
#    $1 * 1000 + $2;
#}
#
#
#sub antique_client
#{
#    my $self = shift;
#    ${*$self}{'httpd_client_proto'} < $HTTP_1_0;
#}
#
#
#sub force_last_request
#{
#    my $self = shift;
#    ${*$self}{'httpd_nomore'}++;
#}
#
#sub head_request
#{
#    my $self = shift;
#    ${*$self}{'httpd_head'};
#}
#
#
#sub send_status_line
#{
#    my($self, $status, $message, $proto) = @_;
#    return if $self->antique_client;
#    $status  ||= RC_OK;
#    $message ||= status_message($status) || "";
#    $proto   ||= $HTTP::Daemon::PROTO || "HTTP/1.1";
#    print $self "$proto $status $message$CRLF";
#}
#
#
#sub send_crlf
#{
#    my $self = shift;
#    print $self $CRLF;
#}
#
#
#sub send_basic_header
#{
#    my $self = shift;
#    return if $self->antique_client;
#    $self->send_status_line(@_);
#    print $self "Date: ", time2str(time), $CRLF;
#    my $product = $self->daemon->product_tokens;
#    print $self "Server: $product$CRLF" if $product;
#}
#
#
#sub send_header
#{
#    my $self = shift;
#    while (@_) {
#	my($k, $v) = splice(@_, 0, 2);
#	$v = "" unless defined($v);
#	print $self "$k: $v$CRLF";
#    }
#}
#
#
#sub send_response
#{
#    my $self = shift;
#    my $res = shift;
#    if (!ref $res) {
#	$res ||= RC_OK;
#	$res = HTTP::Response->new($res, @_);
#    }
#    my $content = $res->content;
#    my $chunked;
#    unless ($self->antique_client) {
#	my $code = $res->code;
#	$self->send_basic_header($code, $res->message, $res->protocol);
#	if ($code =~ /^(1\d\d|[23]04)$/) {
#	    $res->remove_header("Content-Length");
#	    $content = "";
#	}
#	elsif ($res->request && $res->request->method eq "HEAD") {
#	}
#	elsif (ref($content) eq "CODE") {
#	    if ($self->proto_ge("HTTP/1.1")) {
#		$res->push_header("Transfer-Encoding" => "chunked");
#		$chunked++;
#	    }
#	    else {
#		$self->force_last_request;
#	    }
#	}
#	elsif (length($content)) {
#	    $res->header("Content-Length" => length($content));
#	}
#	else {
#	    $self->force_last_request;
#            $res->header('connection','close'); 
#	}
#	print $self $res->headers_as_string($CRLF);
#	print $self $CRLF;  
#    }
#    if ($self->head_request) {
#    }
#    elsif (ref($content) eq "CODE") {
#	while (1) {
#	    my $chunk = &$content();
#	    last unless defined($chunk) && length($chunk);
#	    if ($chunked) {
#		printf $self "%x%s%s%s", length($chunk), $CRLF, $chunk, $CRLF;
#	    }
#	    else {
#		print $self $chunk;
#	    }
#	}
#	print $self "0$CRLF$CRLF" if $chunked;  
#    }
#    elsif (length $content) {
#	print $self $content;
#    }
#}
#
#
#sub send_redirect
#{
#    my($self, $loc, $status, $content) = @_;
#    $status ||= RC_MOVED_PERMANENTLY;
#    Carp::croak("Status '$status' is not redirect") unless is_redirect($status);
#    $self->send_basic_header($status);
#    my $base = $self->daemon->url;
#    $loc = $HTTP::URI_CLASS->new($loc, $base) unless ref($loc);
#    $loc = $loc->abs($base);
#    print $self "Location: $loc$CRLF";
#    if ($content) {
#	my $ct = $content =~ /^\s*</ ? "text/html" : "text/plain";
#	print $self "Content-Type: $ct$CRLF";
#    }
#    print $self $CRLF;
#    print $self $content if $content && !$self->head_request;
#    $self->force_last_request;  
#}
#
#
#sub send_error
#{
#    my($self, $status, $error) = @_;
#    $status ||= RC_BAD_REQUEST;
#    Carp::croak("Status '$status' is not an error") unless is_error($status);
#    my $mess = status_message($status);
#    $error  ||= "";
#    $mess = <<EOT;
#<title>$status $mess</title>
#<h1>$status $mess</h1>
#$error
#EOT
#    unless ($self->antique_client) {
#        $self->send_basic_header($status);
#        print $self "Content-Type: text/html$CRLF";
#	print $self "Content-Length: " . length($mess) . $CRLF;
#        print $self $CRLF;
#    }
#    print $self $mess unless $self->head_request;
#    $status;
#}
#
#
#sub send_file_response
#{
#    my($self, $file) = @_;
#    if (-d $file) {
#	$self->send_dir($file);
#    }
#    elsif (-f _) {
#	local(*F);
#	sysopen(F, $file, 0) or 
#	  return $self->send_error(RC_FORBIDDEN);
#	binmode(F);
#	my($ct,$ce) = guess_media_type($file);
#	my($size,$mtime) = (stat _)[7,9];
#	unless ($self->antique_client) {
#	    $self->send_basic_header;
#	    print $self "Content-Type: $ct$CRLF";
#	    print $self "Content-Encoding: $ce$CRLF" if $ce;
#	    print $self "Content-Length: $size$CRLF" if $size;
#	    print $self "Last-Modified: ", time2str($mtime), "$CRLF" if $mtime;
#	    print $self $CRLF;
#	}
#	$self->send_file(\*F) unless $self->head_request;
#	return RC_OK;
#    }
#    else {
#	$self->send_error(RC_NOT_FOUND);
#    }
#}
#
#
#sub send_dir
#{
#    my($self, $dir) = @_;
#    $self->send_error(RC_NOT_FOUND) unless -d $dir;
#    $self->send_error(RC_NOT_IMPLEMENTED);
#}
#
#
#sub send_file
#{
#    my($self, $file) = @_;
#    my $opened = 0;
#    local(*FILE);
#    if (!ref($file)) {
#	open(FILE, $file) || return undef;
#	binmode(FILE);
#	$file = \*FILE;
#	$opened++;
#    }
#    my $cnt = 0;
#    my $buf = "";
#    my $n;
#    while ($n = sysread($file, $buf, 8*1024)) {
#	last if !$n;
#	$cnt += $n;
#	print $self $buf;
#    }
#    close($file) if $opened;
#    $cnt;
#}
#
#
#sub daemon
#{
#    my $self = shift;
#    ${*$self}{'httpd_daemon'};
#}
#
#
#1;
#
#__END__
#
### HTTP/Date.pm ###
#package HTTP::Date;
#
#$VERSION = "6.02";
#
#require Exporter;
#@ISA = qw(Exporter);
#@EXPORT = qw(time2str str2time);
#@EXPORT_OK = qw(parse_date time2iso time2isoz);
#
#use strict;
#require Time::Local;
#
#use vars qw(@DoW @MoY %MoY);
#@DoW = qw(Sun Mon Tue Wed Thu Fri Sat);
#@MoY = qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec);
#@MoY{@MoY} = (1..12);
#
#my %GMT_ZONE = (GMT => 1, UTC => 1, UT => 1, Z => 1);
#
#
#sub time2str (;$)
#{
#    my $time = shift;
#    $time = time unless defined $time;
#    my ($sec, $min, $hour, $mday, $mon, $year, $wday) = gmtime($time);
#    sprintf("%s, %02d %s %04d %02d:%02d:%02d GMT",
#	    $DoW[$wday],
#	    $mday, $MoY[$mon], $year+1900,
#	    $hour, $min, $sec);
#}
#
#
#sub str2time ($;$)
#{
#    my $str = shift;
#    return undef unless defined $str;
#
#    if ($str =~ /^[SMTWF][a-z][a-z], (\d\d) ([JFMAJSOND][a-z][a-z]) (\d\d\d\d) (\d\d):(\d\d):(\d\d) GMT$/) {
#	return eval {
#	    my $t = Time::Local::timegm($6, $5, $4, $1, $MoY{$2}-1, $3);
#	    $t < 0 ? undef : $t;
#	};
#    }
#
#    my @d = parse_date($str);
#    return undef unless @d;
#    $d[1]--;        
#
#    my $tz = pop(@d);
#    unless (defined $tz) {
#	unless (defined($tz = shift)) {
#	    return eval { my $frac = $d[-1]; $frac -= ($d[-1] = int($frac));
#			  my $t = Time::Local::timelocal(reverse @d) + $frac;
#			  $t < 0 ? undef : $t;
#		        };
#	}
#    }
#
#    my $offset = 0;
#    if ($GMT_ZONE{uc $tz}) {
#    }
#    elsif ($tz =~ /^([-+])?(\d\d?):?(\d\d)?$/) {
#	$offset = 3600 * $2;
#	$offset += 60 * $3 if $3;
#	$offset *= -1 if $1 && $1 eq '-';
#    }
#    else {
#	eval { require Time::Zone } || return undef;
#	$offset = Time::Zone::tz_offset($tz);
#	return undef unless defined $offset;
#    }
#
#    return eval { my $frac = $d[-1]; $frac -= ($d[-1] = int($frac));
#		  my $t = Time::Local::timegm(reverse @d) + $frac;
#		  $t < 0 ? undef : $t - $offset;
#		};
#}
#
#
#sub parse_date ($)
#{
#    local($_) = shift;
#    return unless defined;
#
#    s/^\s+//;  
#    s/^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat)[a-z]*,?\s*//i; 
#
#    my($day, $mon, $yr, $hr, $min, $sec, $tz, $ampm);
#
#    (($day,$mon,$yr,$hr,$min,$sec,$tz) =
#        /^
#	 (\d\d?)               # day
#	    (?:\s+|[-\/])
#	 (\w+)                 # month
#	    (?:\s+|[-\/])
#	 (\d+)                 # year
#	 (?:
#	       (?:\s+|:)       # separator before clock
#	    (\d\d?):(\d\d)     # hour:min
#	    (?::(\d\d))?       # optional seconds
#	 )?                    # optional clock
#	    \s*
#	 ([-+]?\d{2,4}|(?![APap][Mm]\b)[A-Za-z]+)? # timezone
#	    \s*
#	 (?:\(\w+\)|\w{3,})?   # ASCII representation of timezone.
#	    \s*$
#	/x)
#
#    ||
#
#    (($mon, $day, $hr, $min, $sec, $tz, $yr) =
#	/^
#	 (\w{1,3})             # month
#	    \s+
#	 (\d\d?)               # day
#	    \s+
#	 (\d\d?):(\d\d)        # hour:min
#	 (?::(\d\d))?          # optional seconds
#	    \s+
#	 (?:([A-Za-z]+)\s+)?   # optional timezone
#	 (\d+)                 # year
#	    \s*$               # allow trailing whitespace
#	/x)
#
#    ||
#
#    (($mon, $day, $yr, $hr, $min, $sec) =
#	/^
#	 (\w{3})               # month
#	    \s+
#	 (\d\d?)               # day
#	    \s+
#	 (?:
#	    (\d\d\d\d) |       # year
#	    (\d{1,2}):(\d{2})  # hour:min
#            (?::(\d\d))?       # optional seconds
#	 )
#	 \s*$
#       /x)
#
#    ||
#
#    (($yr, $mon, $day, $hr, $min, $sec, $tz) =
#	/^
#	  (\d{4})              # year
#	     [-\/]?
#	  (\d\d?)              # numerical month
#	     [-\/]?
#	  (\d\d?)              # day
#	 (?:
#	       (?:\s+|[-:Tt])  # separator before clock
#	    (\d\d?):?(\d\d)    # hour:min
#	    (?::?(\d\d(?:\.\d*)?))?  # optional seconds (and fractional)
#	 )?                    # optional clock
#	    \s*
#	 ([-+]?\d\d?:?(:?\d\d)?
#	  |Z|z)?               # timezone  (Z is "zero meridian", i.e. GMT)
#	    \s*$
#	/x)
#
#    ||
#
#    (($mon, $day, $yr, $hr, $min, $ampm) =
#        /^
#          (\d{2})                # numerical month
#             -
#          (\d{2})                # day
#             -
#          (\d{2})                # year
#             \s+
#          (\d\d?):(\d\d)([APap][Mm])  # hour:min AM or PM
#             \s*$
#        /x)
#
#    ||
#    return;  
#
#    $mon = $MoY{$mon} ||
#           $MoY{"\u\L$mon"} ||
#	   ($mon =~ /^\d\d?$/ && $mon >= 1 && $mon <= 12 && int($mon)) ||
#           return;
#
#    unless (defined $yr) {
#	my $cur_mon;
#	($cur_mon, $yr) = (localtime)[4, 5];
#	$yr += 1900;
#	$cur_mon++;
#	$yr-- if $mon > $cur_mon;
#    }
#    elsif (length($yr) < 3) {
#	my $cur_yr = (localtime)[5] + 1900;
#	my $m = $cur_yr % 100;
#	my $tmp = $yr;
#	$yr += $cur_yr - $m;
#	$m -= $tmp;
#	$yr += ($m > 0) ? 100 : -100
#	    if abs($m) > 50;
#    }
#
#    $hr  = 0 unless defined($hr);
#    $min = 0 unless defined($min);
#    $sec = 0 unless defined($sec);
#
#    if ($ampm) {
#	$ampm = uc $ampm;
#	$hr = 0 if $hr == 12 && $ampm eq 'AM';
#	$hr += 12 if $ampm eq 'PM' && $hr != 12;
#    }
#
#    return($yr, $mon, $day, $hr, $min, $sec, $tz)
#	if wantarray;
#
#    if (defined $tz) {
#	$tz = "Z" if $tz =~ /^(GMT|UTC?|[-+]?0+)$/;
#    }
#    else {
#	$tz = "";
#    }
#    return sprintf("%04d-%02d-%02d %02d:%02d:%02d%s",
#		   $yr, $mon, $day, $hr, $min, $sec, $tz);
#}
#
#
#sub time2iso (;$)
#{
#    my $time = shift;
#    $time = time unless defined $time;
#    my($sec,$min,$hour,$mday,$mon,$year) = localtime($time);
#    sprintf("%04d-%02d-%02d %02d:%02d:%02d",
#	    $year+1900, $mon+1, $mday, $hour, $min, $sec);
#}
#
#
#sub time2isoz (;$)
#{
#    my $time = shift;
#    $time = time unless defined $time;
#    my($sec,$min,$hour,$mday,$mon,$year) = gmtime($time);
#    sprintf("%04d-%02d-%02d %02d:%02d:%02dZ",
#            $year+1900, $mon+1, $mday, $hour, $min, $sec);
#}
#
#1;
#
#
#__END__
#
### HTTP/Headers.pm ###
#package HTTP::Headers;
#
#use strict;
#use warnings;
#
#use Carp ();
#
#our $VERSION = "6.11";
#
#our $TRANSLATE_UNDERSCORE = 1 unless defined $TRANSLATE_UNDERSCORE;
#
#
#my @general_headers = qw(
#    Cache-Control Connection Date Pragma Trailer Transfer-Encoding Upgrade
#    Via Warning
#);
#
#my @request_headers = qw(
#    Accept Accept-Charset Accept-Encoding Accept-Language
#    Authorization Expect From Host
#    If-Match If-Modified-Since If-None-Match If-Range If-Unmodified-Since
#    Max-Forwards Proxy-Authorization Range Referer TE User-Agent
#);
#
#my @response_headers = qw(
#    Accept-Ranges Age ETag Location Proxy-Authenticate Retry-After Server
#    Vary WWW-Authenticate
#);
#
#my @entity_headers = qw(
#    Allow Content-Encoding Content-Language Content-Length Content-Location
#    Content-MD5 Content-Range Content-Type Expires Last-Modified
#);
#
#my %entity_header = map { lc($_) => 1 } @entity_headers;
#
#my @header_order = (
#    @general_headers,
#    @request_headers,
#    @response_headers,
#    @entity_headers,
#);
#
#my %header_order;
#my %standard_case;
#
#{
#    my $i = 0;
#    for (@header_order) {
#	my $lc = lc $_;
#	$header_order{$lc} = ++$i;
#	$standard_case{$lc} = $_;
#    }
#}
#
#
#
#sub new
#{
#    my($class) = shift;
#    my $self = bless {}, $class;
#    $self->header(@_) if @_; 
#    $self;
#}
#
#
#sub header
#{
#    my $self = shift;
#    Carp::croak('Usage: $h->header($field, ...)') unless @_;
#    my(@old);
#    my %seen;
#    while (@_) {
#	my $field = shift;
#        my $op = @_ ? ($seen{lc($field)}++ ? 'PUSH' : 'SET') : 'GET';
#	@old = $self->_header($field, shift, $op);
#    }
#    return @old if wantarray;
#    return $old[0] if @old <= 1;
#    join(", ", @old);
#}
#
#sub clear
#{
#    my $self = shift;
#    %$self = ();
#}
#
#
#sub push_header
#{
#    my $self = shift;
#    return $self->_header(@_, 'PUSH_H') if @_ == 2;
#    while (@_) {
#	$self->_header(splice(@_, 0, 2), 'PUSH_H');
#    }
#}
#
#
#sub init_header
#{
#    Carp::croak('Usage: $h->init_header($field, $val)') if @_ != 3;
#    shift->_header(@_, 'INIT');
#}
#
#
#sub remove_header
#{
#    my($self, @fields) = @_;
#    my $field;
#    my @values;
#    foreach $field (@fields) {
#	$field =~ tr/_/-/ if $field !~ /^:/ && $TRANSLATE_UNDERSCORE;
#	my $v = delete $self->{lc $field};
#	push(@values, ref($v) eq 'ARRAY' ? @$v : $v) if defined $v;
#    }
#    return @values;
#}
#
#sub remove_content_headers
#{
#    my $self = shift;
#    unless (defined(wantarray)) {
#	delete @$self{grep $entity_header{$_} || /^content-/, keys %$self};
#	return;
#    }
#
#    my $c = ref($self)->new;
#    for my $f (grep $entity_header{$_} || /^content-/, keys %$self) {
#	$c->{$f} = delete $self->{$f};
#    }
#    if (exists $self->{'::std_case'}) {
#	$c->{'::std_case'} = $self->{'::std_case'};
#    }
#    $c;
#}
#
#
#sub _header
#{
#    my($self, $field, $val, $op) = @_;
#
#    Carp::croak("Illegal field name '$field'")
#        if rindex($field, ':') > 1 || !length($field);
#
#    unless ($field =~ /^:/) {
#	$field =~ tr/_/-/ if $TRANSLATE_UNDERSCORE;
#	my $old = $field;
#	$field = lc $field;
#	unless($standard_case{$field} || $self->{'::std_case'}{$field}) {
#	    $old =~ s/\b(\w)/\u$1/g;
#	    $self->{'::std_case'}{$field} = $old;
#	}
#    }
#
#    $op ||= defined($val) ? 'SET' : 'GET';
#    if ($op eq 'PUSH_H') {
#	if (exists $self->{$field}) {
#	    my $h = $self->{$field};
#	    if (ref($h) eq 'ARRAY') {
#		push(@$h, ref($val) eq "ARRAY" ? @$val : $val);
#	    }
#	    else {
#		$self->{$field} = [$h, ref($val) eq "ARRAY" ? @$val : $val]
#	    }
#	    return;
#	}
#	$self->{$field} = $val;
#	return;
#    }
#
#    my $h = $self->{$field};
#    my @old = ref($h) eq 'ARRAY' ? @$h : (defined($h) ? ($h) : ());
#
#    unless ($op eq 'GET' || ($op eq 'INIT' && @old)) {
#	if (defined($val)) {
#	    my @new = ($op eq 'PUSH') ? @old : ();
#	    if (ref($val) ne 'ARRAY') {
#		push(@new, $val);
#	    }
#	    else {
#		push(@new, @$val);
#	    }
#	    $self->{$field} = @new > 1 ? \@new : $new[0];
#	}
#	elsif ($op ne 'PUSH') {
#	    delete $self->{$field};
#	}
#    }
#    @old;
#}
#
#
#sub _sorted_field_names
#{
#    my $self = shift;
#    return [ sort {
#        ($header_order{$a} || 999) <=> ($header_order{$b} || 999) ||
#         $a cmp $b
#    } grep !/^::/, keys %$self ];
#}
#
#
#sub header_field_names {
#    my $self = shift;
#    return map $standard_case{$_} || $self->{'::std_case'}{$_} || $_, @{ $self->_sorted_field_names },
#	if wantarray;
#    return grep !/^::/, keys %$self;
#}
#
#
#sub scan
#{
#    my($self, $sub) = @_;
#    my $key;
#    for $key (@{ $self->_sorted_field_names }) {
#	my $vals = $self->{$key};
#	if (ref($vals) eq 'ARRAY') {
#	    my $val;
#	    for $val (@$vals) {
#		$sub->($standard_case{$key} || $self->{'::std_case'}{$key} || $key, $val);
#	    }
#	}
#	else {
#	    $sub->($standard_case{$key} || $self->{'::std_case'}{$key} || $key, $vals);
#	}
#    }
#}
#
#sub flatten {
#	my($self)=@_;
#
#	(
#		map {
#			my $k = $_;
#			map {
#				( $k => $_ )
#			} $self->header($_);
#		} $self->header_field_names
#	);
#}
#
#sub as_string
#{
#    my($self, $endl) = @_;
#    $endl = "\n" unless defined $endl;
#
#    my @result = ();
#    for my $key (@{ $self->_sorted_field_names }) {
#	next if index($key, '_') == 0;
#	my $vals = $self->{$key};
#	if ( ref($vals) eq 'ARRAY' ) {
#	    for my $val (@$vals) {
#		$val = '' if not defined $val;
#		my $field = $standard_case{$key} || $self->{'::std_case'}{$key} || $key;
#		$field =~ s/^://;
#		if ( index($val, "\n") >= 0 ) {
#		    $val = _process_newline($val, $endl);
#		}
#		push @result, $field . ': ' . $val;
#	    }
#	}
#	else {
#	    $vals = '' if not defined $vals;
#	    my $field = $standard_case{$key} || $self->{'::std_case'}{$key} || $key;
#	    $field =~ s/^://;
#	    if ( index($vals, "\n") >= 0 ) {
#		$vals = _process_newline($vals, $endl);
#	    }
#	    push @result, $field . ': ' . $vals;
#	}
#    }
#
#    join($endl, @result, '');
#}
#
#sub _process_newline {
#    local $_ = shift;
#    my $endl = shift;
#    s/\s+$//;        
#    s/\n(\x0d?\n)+/\n/g;     
#    s/\n([^\040\t])/\n $1/g; 
#    s/\n/$endl/g;    
#    $_;
#}
#
#
#
#if (eval { require Storable; 1 }) {
#    *clone = \&Storable::dclone;
#} else {
#    *clone = sub {
#	my $self = shift;
#	my $clone = HTTP::Headers->new;
#	$self->scan(sub { $clone->push_header(@_);} );
#	$clone;
#    };
#}
#
#
#sub _date_header
#{
#    require HTTP::Date;
#    my($self, $header, $time) = @_;
#    my($old) = $self->_header($header);
#    if (defined $time) {
#	$self->_header($header, HTTP::Date::time2str($time));
#    }
#    $old =~ s/;.*// if defined($old);
#    HTTP::Date::str2time($old);
#}
#
#
#sub date                { shift->_date_header('Date',                @_); }
#sub expires             { shift->_date_header('Expires',             @_); }
#sub if_modified_since   { shift->_date_header('If-Modified-Since',   @_); }
#sub if_unmodified_since { shift->_date_header('If-Unmodified-Since', @_); }
#sub last_modified       { shift->_date_header('Last-Modified',       @_); }
#
#sub client_date         { shift->_date_header('Client-Date',         @_); }
#
#
#sub content_type      {
#    my $self = shift;
#    my $ct = $self->{'content-type'};
#    $self->{'content-type'} = shift if @_;
#    $ct = $ct->[0] if ref($ct) eq 'ARRAY';
#    return '' unless defined($ct) && length($ct);
#    my @ct = split(/;\s*/, $ct, 2);
#    for ($ct[0]) {
#	s/\s+//g;
#	$_ = lc($_);
#    }
#    wantarray ? @ct : $ct[0];
#}
#
#sub content_type_charset {
#    my $self = shift;
#    require HTTP::Headers::Util;
#    my $h = $self->{'content-type'};
#    $h = $h->[0] if ref($h);
#    $h = "" unless defined $h;
#    my @v = HTTP::Headers::Util::split_header_words($h);
#    if (@v) {
#	my($ct, undef, %ct_param) = @{$v[0]};
#	my $charset = $ct_param{charset};
#	if ($ct) {
#	    $ct = lc($ct);
#	    $ct =~ s/\s+//;
#	}
#	if ($charset) {
#	    $charset = uc($charset);
#	    $charset =~ s/^\s+//;  $charset =~ s/\s+\z//;
#	    undef($charset) if $charset eq "";
#	}
#	return $ct, $charset if wantarray;
#	return $charset;
#    }
#    return undef, undef if wantarray;
#    return undef;
#}
#
#sub content_is_text {
#    my $self = shift;
#    return $self->content_type =~ m,^text/,;
#}
#
#sub content_is_html {
#    my $self = shift;
#    return $self->content_type eq 'text/html' || $self->content_is_xhtml;
#}
#
#sub content_is_xhtml {
#    my $ct = shift->content_type;
#    return $ct eq "application/xhtml+xml" ||
#           $ct eq "application/vnd.wap.xhtml+xml";
#}
#
#sub content_is_xml {
#    my $ct = shift->content_type;
#    return 1 if $ct eq "text/xml";
#    return 1 if $ct eq "application/xml";
#    return 1 if $ct =~ /\+xml$/;
#    return 0;
#}
#
#sub referer           {
#    my $self = shift;
#    if (@_ && $_[0] =~ /#/) {
#	my $uri = shift;
#	if (ref($uri)) {
#	    $uri = $uri->clone;
#	    $uri->fragment(undef);
#	}
#	else {
#	    $uri =~ s/\#.*//;
#	}
#	unshift @_, $uri;
#    }
#    ($self->_header('Referer', @_))[0];
#}
#*referrer = \&referer;  
#
#sub title             { (shift->_header('Title',            @_))[0] }
#sub content_encoding  { (shift->_header('Content-Encoding', @_))[0] }
#sub content_language  { (shift->_header('Content-Language', @_))[0] }
#sub content_length    { (shift->_header('Content-Length',   @_))[0] }
#
#sub user_agent        { (shift->_header('User-Agent',       @_))[0] }
#sub server            { (shift->_header('Server',           @_))[0] }
#
#sub from              { (shift->_header('From',             @_))[0] }
#sub warning           { (shift->_header('Warning',          @_))[0] }
#
#sub www_authenticate  { (shift->_header('WWW-Authenticate', @_))[0] }
#sub authorization     { (shift->_header('Authorization',    @_))[0] }
#
#sub proxy_authenticate  { (shift->_header('Proxy-Authenticate',  @_))[0] }
#sub proxy_authorization { (shift->_header('Proxy-Authorization', @_))[0] }
#
#sub authorization_basic       { shift->_basic_auth("Authorization",       @_) }
#sub proxy_authorization_basic { shift->_basic_auth("Proxy-Authorization", @_) }
#
#sub _basic_auth {
#    require MIME::Base64;
#    my($self, $h, $user, $passwd) = @_;
#    my($old) = $self->_header($h);
#    if (defined $user) {
#	Carp::croak("Basic authorization user name can't contain ':'")
#	  if $user =~ /:/;
#	$passwd = '' unless defined $passwd;
#	$self->_header($h => 'Basic ' .
#                             MIME::Base64::encode("$user:$passwd", ''));
#    }
#    if (defined $old && $old =~ s/^\s*Basic\s+//) {
#	my $val = MIME::Base64::decode($old);
#	return $val unless wantarray;
#	return split(/:/, $val, 2);
#    }
#    return;
#}
#
#
#1;
#
#__END__
#
### HTTP/Headers/Auth.pm ###
#package HTTP::Headers::Auth;
#
#use strict;
#use warnings;
#
#our $VERSION = "6.11";
#
#use HTTP::Headers;
#
#package
#    HTTP::Headers;
#
#BEGIN {
#    undef(&www_authenticate);
#    undef(&proxy_authenticate);
#}
#
#require HTTP::Headers::Util;
#
#sub _parse_authenticate
#{
#    my @ret;
#    for (HTTP::Headers::Util::split_header_words(@_)) {
#	if (!defined($_->[1])) {
#	    push(@ret, shift(@$_) => {});
#	    shift @$_;
#	}
#	if (@ret) {
#	    while (@$_) {
#		my $k = shift @$_;
#		my $v = shift @$_;
#	        $ret[-1]{$k} = $v;
#	    }
#	}
#	else {
#	}
#    }
#    @ret;
#}
#
#sub _authenticate
#{
#    my $self = shift;
#    my $header = shift;
#    my @old = $self->_header($header);
#    if (@_) {
#	$self->remove_header($header);
#	my @new = @_;
#	while (@new) {
#	    my $a_scheme = shift(@new);
#	    if ($a_scheme =~ /\s/) {
#		$self->push_header($header, $a_scheme);
#	    }
#	    else {
#		my @param;
#		if (@new) {
#		    my $p = $new[0];
#		    if (ref($p) eq "ARRAY") {
#			@param = @$p;
#			shift(@new);
#		    }
#		    elsif (ref($p) eq "HASH") {
#			@param = %$p;
#			shift(@new);
#		    }
#		}
#		my $val = ucfirst(lc($a_scheme));
#		if (@param) {
#		    my $sep = " ";
#		    while (@param) {
#			my $k = shift @param;
#			my $v = shift @param;
#			if ($v =~ /[^0-9a-zA-Z]/ || lc($k) eq "realm") {
#			    $v =~ s,([\\\"]),\\$1,g;
#			    $v = qq("$v");
#			}
#			$val .= "$sep$k=$v";
#			$sep = ", ";
#		    }
#		}
#		$self->push_header($header, $val);
#	    }
#	}
#    }
#    return unless defined wantarray;
#    wantarray ? _parse_authenticate(@old) : join(", ", @old);
#}
#
#
#sub www_authenticate    { shift->_authenticate("WWW-Authenticate", @_)   }
#sub proxy_authenticate  { shift->_authenticate("Proxy-Authenticate", @_) }
#
#1;
### HTTP/Headers/ETag.pm ###
#package HTTP::Headers::ETag;
#
#use strict;
#use warnings;
#
#our $VERSION = "6.11";
#
#require HTTP::Date;
#
#require HTTP::Headers;
#package
#    HTTP::Headers;
#
#sub _etags
#{
#    my $self = shift;
#    my $header = shift;
#    my @old = _split_etag_list($self->_header($header));
#    if (@_) {
#	$self->_header($header => join(", ", _split_etag_list(@_)));
#    }
#    wantarray ? @old : join(", ", @old);
#}
#
#sub etag          { shift->_etags("ETag", @_); }
#sub if_match      { shift->_etags("If-Match", @_); }
#sub if_none_match { shift->_etags("If-None-Match", @_); }
#
#sub if_range {
#    my $self = shift;
#    my @old = $self->_header("If-Range");
#    if (@_) {
#	my $new = shift;
#	if (!defined $new) {
#	    $self->remove_header("If-Range");
#	}
#	elsif ($new =~ /^\d+$/) {
#	    $self->_date_header("If-Range", $new);
#	}
#	else {
#	    $self->_etags("If-Range", $new);
#	}
#    }
#    return unless defined(wantarray);
#    for (@old) {
#	my $t = HTTP::Date::str2time($_);
#	$_ = $t if $t;
#    }
#    wantarray ? @old : join(", ", @old);
#}
#
#
#
#
#sub _split_etag_list
#{
#    my(@val) = @_;
#    my @res;
#    for (@val) {
#        while (length) {
#            my $weak = "";
#	    $weak = "W/" if s,^\s*[wW]/,,;
#            my $etag = "";
#	    if (s/^\s*(\"[^\"\\]*(?:\\.[^\"\\]*)*\")//) {
#		push(@res, "$weak$1");
#            }
#            elsif (s/^\s*,//) {
#                push(@res, qq(W/"")) if $weak;
#            }
#            elsif (s/^\s*([^,\s]+)//) {
#                $etag = $1;
#		$etag =~ s/([\"\\])/\\$1/g;
#	        push(@res, qq($weak"$etag"));
#            }
#            elsif (s/^\s+// || !length) {
#                push(@res, qq(W/"")) if $weak;
#            }
#            else {
#	 	die "This should not happen: '$_'";
#            }
#        }
#   }
#   @res;
#}
#
#1;
### HTTP/Headers/Util.pm ###
#package HTTP::Headers::Util;
#
#use strict;
#use warnings;
#
#our $VERSION = "6.11";
#
#use base 'Exporter';
#
#our @EXPORT_OK=qw(split_header_words _split_header_words join_header_words);
#
#
#sub split_header_words {
#    my @res = &_split_header_words;
#    for my $arr (@res) {
#	for (my $i = @$arr - 2; $i >= 0; $i -= 2) {
#	    $arr->[$i] = lc($arr->[$i]);
#	}
#    }
#    return @res;
#}
#
#sub _split_header_words
#{
#    my(@val) = @_;
#    my @res;
#    for (@val) {
#	my @cur;
#	while (length) {
#	    if (s/^\s*(=*[^\s=;,]+)//) {  
#		push(@cur, $1);
#		if (s/^\s*=\s*\"([^\"\\]*(?:\\.[^\"\\]*)*)\"//) {
#		    my $val = $1;
#		    $val =~ s/\\(.)/$1/g;
#		    push(@cur, $val);
#		}
#		elsif (s/^\s*=\s*([^;,\s]*)//) {
#		    my $val = $1;
#		    $val =~ s/\s+$//;
#		    push(@cur, $val);
#		}
#		else {
#		    push(@cur, undef);
#		}
#	    }
#	    elsif (s/^\s*,//) {
#		push(@res, [@cur]) if @cur;
#		@cur = ();
#	    }
#	    elsif (s/^\s*;// || s/^\s+//) {
#	    }
#	    else {
#		die "This should not happen: '$_'";
#	    }
#	}
#	push(@res, \@cur) if @cur;
#    }
#    @res;
#}
#
#
#sub join_header_words
#{
#    @_ = ([@_]) if @_ && !ref($_[0]);
#    my @res;
#    for (@_) {
#	my @cur = @$_;
#	my @attr;
#	while (@cur) {
#	    my $k = shift @cur;
#	    my $v = shift @cur;
#	    if (defined $v) {
#		if ($v =~ /[\x00-\x20()<>@,;:\\\"\/\[\]?={}\x7F-\xFF]/ || !length($v)) {
#		    $v =~ s/([\"\\])/\\$1/g;  
#		    $k .= qq(="$v");
#		}
#		else {
#		    $k .= "=$v";
#		}
#	    }
#	    push(@attr, $k);
#	}
#	push(@res, join("; ", @attr)) if @attr;
#    }
#    join(", ", @res);
#}
#
#
#1;
#
#__END__
#
### HTTP/Message.pm ###
#package HTTP::Message;
#
#use strict;
#use warnings;
#
#our $VERSION = "6.11";
#
#require HTTP::Headers;
#require Carp;
#
#my $CRLF = "\015\012";   
#unless ($HTTP::URI_CLASS) {
#    if ($ENV{PERL_HTTP_URI_CLASS}
#    &&  $ENV{PERL_HTTP_URI_CLASS} =~ /^([\w:]+)$/) {
#        $HTTP::URI_CLASS = $1;
#    } else {
#        $HTTP::URI_CLASS = "URI";
#    }
#}
#eval "require $HTTP::URI_CLASS"; die $@ if $@;
#
#*_utf8_downgrade = defined(&utf8::downgrade) ?
#    sub {
#        utf8::downgrade($_[0], 1) or
#            Carp::croak("HTTP::Message content must be bytes")
#    }
#    :
#    sub {
#    };
#
#sub new
#{
#    my($class, $header, $content) = @_;
#    if (defined $header) {
#	Carp::croak("Bad header argument") unless ref $header;
#        if (ref($header) eq "ARRAY") {
#	    $header = HTTP::Headers->new(@$header);
#	}
#	else {
#	    $header = $header->clone;
#	}
#    }
#    else {
#	$header = HTTP::Headers->new;
#    }
#    if (defined $content) {
#        _utf8_downgrade($content);
#    }
#    else {
#        $content = '';
#    }
#
#    bless {
#	'_headers' => $header,
#	'_content' => $content,
#    }, $class;
#}
#
#
#sub parse
#{
#    my($class, $str) = @_;
#
#    my @hdr;
#    while (1) {
#	if ($str =~ s/^([^\s:]+)[ \t]*: ?(.*)\n?//) {
#	    push(@hdr, $1, $2);
#	    $hdr[-1] =~ s/\r\z//;
#	}
#	elsif (@hdr && $str =~ s/^([ \t].*)\n?//) {
#	    $hdr[-1] .= "\n$1";
#	    $hdr[-1] =~ s/\r\z//;
#	}
#	else {
#	    $str =~ s/^\r?\n//;
#	    last;
#	}
#    }
#    local $HTTP::Headers::TRANSLATE_UNDERSCORE;
#    new($class, \@hdr, $str);
#}
#
#
#sub clone
#{
#    my $self  = shift;
#    my $clone = HTTP::Message->new($self->headers,
#				   $self->content);
#    $clone->protocol($self->protocol);
#    $clone;
#}
#
#
#sub clear {
#    my $self = shift;
#    $self->{_headers}->clear;
#    $self->content("");
#    delete $self->{_parts};
#    return;
#}
#
#
#sub protocol {
#    shift->_elem('_protocol',  @_);
#}
#
#sub headers {
#    my $self = shift;
#
#    $self->_content unless exists $self->{_content};
#
#    $self->{_headers};
#}
#
#sub headers_as_string {
#    shift->headers->as_string(@_);
#}
#
#
#sub content  {
#
#    my $self = $_[0];
#    if (defined(wantarray)) {
#	$self->_content unless exists $self->{_content};
#	my $old = $self->{_content};
#	$old = $$old if ref($old) eq "SCALAR";
#	&_set_content if @_ > 1;
#	return $old;
#    }
#
#    if (@_ > 1) {
#	&_set_content;
#    }
#    else {
#	Carp::carp("Useless content call in void context") if $^W;
#    }
#}
#
#
#sub _set_content {
#    my $self = $_[0];
#    _utf8_downgrade($_[1]);
#    if (!ref($_[1]) && ref($self->{_content}) eq "SCALAR") {
#	${$self->{_content}} = $_[1];
#    }
#    else {
#	die "Can't set content to be a scalar reference" if ref($_[1]) eq "SCALAR";
#	$self->{_content} = $_[1];
#	delete $self->{_content_ref};
#    }
#    delete $self->{_parts} unless $_[2];
#}
#
#
#sub add_content
#{
#    my $self = shift;
#    $self->_content unless exists $self->{_content};
#    my $chunkref = \$_[0];
#    $chunkref = $$chunkref if ref($$chunkref);  
#
#    _utf8_downgrade($$chunkref);
#
#    my $ref = ref($self->{_content});
#    if (!$ref) {
#	$self->{_content} .= $$chunkref;
#    }
#    elsif ($ref eq "SCALAR") {
#	${$self->{_content}} .= $$chunkref;
#    }
#    else {
#	Carp::croak("Can't append to $ref content");
#    }
#    delete $self->{_parts};
#}
#
#sub add_content_utf8 {
#    my($self, $buf)  = @_;
#    utf8::upgrade($buf);
#    utf8::encode($buf);
#    $self->add_content($buf);
#}
#
#sub content_ref
#{
#    my $self = shift;
#    $self->_content unless exists $self->{_content};
#    delete $self->{_parts};
#    my $old = \$self->{_content};
#    my $old_cref = $self->{_content_ref};
#    if (@_) {
#	my $new = shift;
#	Carp::croak("Setting content_ref to a non-ref") unless ref($new);
#	delete $self->{_content};  
#	$self->{_content} = $new;
#	$self->{_content_ref}++;
#    }
#    $old = $$old if $old_cref;
#    return $old;
#}
#
#
#sub content_charset
#{
#    my $self = shift;
#    if (my $charset = $self->content_type_charset) {
#	return $charset;
#    }
#
#    my $cref = $self->decoded_content(ref => 1, charset => "none");
#
#    for ($$cref) {
#	return "UTF-8"     if /^\xEF\xBB\xBF/;
#	return "UTF-32LE" if /^\xFF\xFE\x00\x00/;
#	return "UTF-32BE" if /^\x00\x00\xFE\xFF/;
#	return "UTF-16LE" if /^\xFF\xFE/;
#	return "UTF-16BE" if /^\xFE\xFF/;
#    }
#
#    if ($self->content_is_xml) {
#	for ($$cref) {
#	    return "UTF-32BE" if /^\x00\x00\x00</;
#	    return "UTF-32LE" if /^<\x00\x00\x00/;
#	    return "UTF-16BE" if /^(?:\x00\s)*\x00</;
#	    return "UTF-16LE" if /^(?:\s\x00)*<\x00/;
#	    if (/^\s*(<\?xml[^\x00]*?\?>)/) {
#		if ($1 =~ /\sencoding\s*=\s*(["'])(.*?)\1/) {
#		    my $enc = $2;
#		    $enc =~ s/^\s+//; $enc =~ s/\s+\z//;
#		    return $enc if $enc;
#		}
#	    }
#	}
#	return "UTF-8";
#    }
#    elsif ($self->content_is_html) {
#	require IO::HTML;
#	my $encoding = IO::HTML::find_charset_in($$cref, { encoding    => 1,
#	                                                   need_pragma => 0 });
#	return $encoding->mime_name if $encoding;
#    }
#    elsif ($self->content_type eq "application/json") {
#	for ($$cref) {
#	    return "UTF-32BE" if /^\x00\x00\x00./s;
#	    return "UTF-32LE" if /^.\x00\x00\x00/s;
#	    return "UTF-16BE" if /^\x00.\x00./s;
#	    return "UTF-16LE" if /^.\x00.\x00/s;
#	    return "UTF-8";
#	}
#    }
#    if ($self->content_type =~ /^text\//) {
#	for ($$cref) {
#	    if (length) {
#		return "US-ASCII" unless /[\x80-\xFF]/;
#		require Encode;
#		eval {
#		    Encode::decode_utf8($_, Encode::FB_CROAK() | Encode::LEAVE_SRC());
#		};
#		return "UTF-8" unless $@;
#		return "ISO-8859-1";
#	    }
#	}
#    }
#
#    return undef;
#}
#
#
#sub decoded_content
#{
#    my($self, %opt) = @_;
#    my $content_ref;
#    my $content_ref_iscopy;
#
#    eval {
#	$content_ref = $self->content_ref;
#	die "Can't decode ref content" if ref($content_ref) ne "SCALAR";
#
#	if (my $h = $self->header("Content-Encoding")) {
#	    $h =~ s/^\s+//;
#	    $h =~ s/\s+$//;
#	    for my $ce (reverse split(/\s*,\s*/, lc($h))) {
#		next unless $ce;
#		next if $ce eq "identity" || $ce eq "none";
#		if ($ce eq "gzip" || $ce eq "x-gzip") {
#		    require IO::Uncompress::Gunzip;
#		    my $output;
#		    IO::Uncompress::Gunzip::gunzip($content_ref, \$output, Transparent => 0)
#			or die "Can't gunzip content: $IO::Uncompress::Gunzip::GunzipError";
#		    $content_ref = \$output;
#		    $content_ref_iscopy++;
#		}
#		elsif ($ce eq "x-bzip2" or $ce eq "bzip2") {
#		    require IO::Uncompress::Bunzip2;
#		    my $output;
#		    IO::Uncompress::Bunzip2::bunzip2($content_ref, \$output, Transparent => 0)
#			or die "Can't bunzip content: $IO::Uncompress::Bunzip2::Bunzip2Error";
#		    $content_ref = \$output;
#		    $content_ref_iscopy++;
#		}
#		elsif ($ce eq "deflate") {
#		    require IO::Uncompress::Inflate;
#		    my $output;
#		    my $status = IO::Uncompress::Inflate::inflate($content_ref, \$output, Transparent => 0);
#		    my $error = $IO::Uncompress::Inflate::InflateError;
#		    unless ($status) {
#			$output = undef;
#			require IO::Uncompress::RawInflate;
#			unless (IO::Uncompress::RawInflate::rawinflate($content_ref, \$output)) {
#			    $self->push_header("Client-Warning" =>
#				"Could not raw inflate content: $IO::Uncompress::RawInflate::RawInflateError");
#			    $output = undef;
#			}
#		    }
#		    die "Can't inflate content: $error" unless defined $output;
#		    $content_ref = \$output;
#		    $content_ref_iscopy++;
#		}
#		elsif ($ce eq "compress" || $ce eq "x-compress") {
#		    die "Can't uncompress content";
#		}
#		elsif ($ce eq "base64") {  
#		    require MIME::Base64;
#		    $content_ref = \MIME::Base64::decode($$content_ref);
#		    $content_ref_iscopy++;
#		}
#		elsif ($ce eq "quoted-printable") { 
#		    require MIME::QuotedPrint;
#		    $content_ref = \MIME::QuotedPrint::decode($$content_ref);
#		    $content_ref_iscopy++;
#		}
#		else {
#		    die "Don't know how to decode Content-Encoding '$ce'";
#		}
#	    }
#	}
#
#	if ($self->content_is_text || (my $is_xml = $self->content_is_xml)) {
#	    my $charset = lc(
#	        $opt{charset} ||
#		$self->content_type_charset ||
#		$opt{default_charset} ||
#		$self->content_charset ||
#		"ISO-8859-1"
#	    );
#	    if ($charset eq "none") {
#	    }
#	    elsif ($charset eq "us-ascii" || $charset eq "iso-8859-1") {
#		if ($$content_ref =~ /[^\x00-\x7F]/ && defined &utf8::upgrade) {
#		    unless ($content_ref_iscopy) {
#			my $copy = $$content_ref;
#			$content_ref = \$copy;
#			$content_ref_iscopy++;
#		    }
#		    utf8::upgrade($$content_ref);
#		}
#	    }
#	    else {
#		require Encode;
#		eval {
#		    $content_ref = \Encode::decode($charset, $$content_ref,
#			 ($opt{charset_strict} ? Encode::FB_CROAK() : 0) | Encode::LEAVE_SRC());
#		};
#		if ($@) {
#		    my $retried;
#		    if ($@ =~ /^Unknown encoding/) {
#			my $alt_charset = lc($opt{alt_charset} || "");
#			if ($alt_charset && $charset ne $alt_charset) {
#			    $content_ref = \Encode::decode($alt_charset, $$content_ref,
#				 ($opt{charset_strict} ? Encode::FB_CROAK() : 0) | Encode::LEAVE_SRC())
#			        unless $alt_charset eq "none";
#			    $retried++;
#			}
#		    }
#		    die unless $retried;
#		}
#		die "Encode::decode() returned undef improperly" unless defined $$content_ref;
#		if ($is_xml) {
#		    $$content_ref =~ s/^\x{FEFF}//;
#		    if ($$content_ref =~ /^(\s*<\?xml[^\x00]*?\?>)/) {
#			substr($$content_ref, 0, length($1)) =~ s/\sencoding\s*=\s*(["']).*?\1//;
#		    }
#		}
#	    }
#	}
#    };
#    if ($@) {
#	Carp::croak($@) if $opt{raise_error};
#	return undef;
#    }
#
#    return $opt{ref} ? $content_ref : $$content_ref;
#}
#
#
#sub decodable
#{
#    my $self = shift;
#    my @enc;
#    eval {
#        require IO::Uncompress::Gunzip;
#        push(@enc, "gzip", "x-gzip");
#    };
#    eval {
#        require IO::Uncompress::Inflate;
#        require IO::Uncompress::RawInflate;
#        push(@enc, "deflate");
#    };
#    eval {
#        require IO::Uncompress::Bunzip2;
#        push(@enc, "x-bzip2");
#    };
#    return wantarray ? @enc : join(", ", @enc);
#}
#
#
#sub decode
#{
#    my $self = shift;
#    return 1 unless $self->header("Content-Encoding");
#    if (defined(my $content = $self->decoded_content(charset => "none"))) {
#	$self->remove_header("Content-Encoding", "Content-Length", "Content-MD5");
#	$self->content($content);
#	return 1;
#    }
#    return 0;
#}
#
#
#sub encode
#{
#    my($self, @enc) = @_;
#
#    Carp::croak("Can't encode multipart/* messages") if $self->content_type =~ m,^multipart/,;
#    Carp::croak("Can't encode message/* messages") if $self->content_type =~ m,^message/,;
#
#    return 1 unless @enc;  
#
#    my $content = $self->content;
#    for my $encoding (@enc) {
#	if ($encoding eq "identity") {
#	}
#	elsif ($encoding eq "base64") {
#	    require MIME::Base64;
#	    $content = MIME::Base64::encode($content);
#	}
#	elsif ($encoding eq "gzip" || $encoding eq "x-gzip") {
#	    require IO::Compress::Gzip;
#	    my $output;
#	    IO::Compress::Gzip::gzip(\$content, \$output, Minimal => 1)
#		or die "Can't gzip content: $IO::Compress::Gzip::GzipError";
#	    $content = $output;
#	}
#	elsif ($encoding eq "deflate") {
#	    require IO::Compress::Deflate;
#	    my $output;
#	    IO::Compress::Deflate::deflate(\$content, \$output)
#		or die "Can't deflate content: $IO::Compress::Deflate::DeflateError";
#	    $content = $output;
#	}
#	elsif ($encoding eq "x-bzip2") {
#	    require IO::Compress::Bzip2;
#	    my $output;
#	    IO::Compress::Bzip2::bzip2(\$content, \$output)
#		or die "Can't bzip2 content: $IO::Compress::Bzip2::Bzip2Error";
#	    $content = $output;
#	}
#	elsif ($encoding eq "rot13") {  
#	    $content =~ tr/A-Za-z/N-ZA-Mn-za-m/;
#	}
#	else {
#	    return 0;
#	}
#    }
#    my $h = $self->header("Content-Encoding");
#    unshift(@enc, $h) if $h;
#    $self->header("Content-Encoding", join(", ", @enc));
#    $self->remove_header("Content-Length", "Content-MD5");
#    $self->content($content);
#    return 1;
#}
#
#
#sub as_string
#{
#    my($self, $eol) = @_;
#    $eol = "\n" unless defined $eol;
#
#    my $content = $self->content;
#
#    return join("", $self->{'_headers'}->as_string($eol),
#		    $eol,
#		    $content,
#		    (@_ == 1 && length($content) &&
#		     $content !~ /\n\z/) ? "\n" : "",
#		);
#}
#
#
#sub dump
#{
#    my($self, %opt) = @_;
#    my $content = $self->content;
#    my $chopped = 0;
#    if (!ref($content)) {
#	my $maxlen = $opt{maxlength};
#	$maxlen = 512 unless defined($maxlen);
#	if ($maxlen && length($content) > $maxlen * 1.1 + 3) {
#	    $chopped = length($content) - $maxlen;
#	    $content = substr($content, 0, $maxlen) . "...";
#	}
#
#	$content =~ s/\\/\\\\/g;
#	$content =~ s/\t/\\t/g;
#	$content =~ s/\r/\\r/g;
#
#	$content =~ s/([\0-\11\13-\037])(?!\d)/sprintf('\\%o',ord($1))/eg;
#
#	$content =~ s/([\0-\11\13-\037\177-\377])/sprintf('\\x%02X',ord($1))/eg;
#	$content =~ s/([^\12\040-\176])/sprintf('\\x{%X}',ord($1))/eg;
#
#	$content =~ s/( +)\n/("\\40" x length($1)) . "\n"/eg;
#	$content =~ s/(\n+)\n/("\\n" x length($1)) . "\n"/eg;
#	$content =~ s/\n\z/\\n/;
#
#	my $no_content = $opt{no_content};
#	$no_content = "(no content)" unless defined $no_content;
#	if ($content eq $no_content) {
#	    $content =~ s/^(.)/sprintf('\\x%02X',ord($1))/eg;
#	}
#	elsif ($content eq "") {
#	    $content = $no_content;
#	}
#    }
#
#    my @dump;
#    push(@dump, $opt{preheader}) if $opt{preheader};
#    push(@dump, $self->{_headers}->as_string, $content);
#    push(@dump, "(+ $chopped more bytes not shown)") if $chopped;
#
#    my $dump = join("\n", @dump, "");
#    $dump =~ s/^/$opt{prefix}/gm if $opt{prefix};
#
#    print $dump unless defined wantarray;
#    return $dump;
#}
#
#sub _part_class {
#    return __PACKAGE__;
#}
#
#sub parts {
#    my $self = shift;
#    if (defined(wantarray) && (!exists $self->{_parts} || ref($self->{_content}) eq "SCALAR")) {
#	$self->_parts;
#    }
#    my $old = $self->{_parts};
#    if (@_) {
#	my @parts = map { ref($_) eq 'ARRAY' ? @$_ : $_ } @_;
#	my $ct = $self->content_type || "";
#	if ($ct =~ m,^message/,) {
#	    Carp::croak("Only one part allowed for $ct content")
#		if @parts > 1;
#	}
#	elsif ($ct !~ m,^multipart/,) {
#	    $self->remove_content_headers;
#	    $self->content_type("multipart/mixed");
#	}
#	$self->{_parts} = \@parts;
#	_stale_content($self);
#    }
#    return @$old if wantarray;
#    return $old->[0];
#}
#
#sub add_part {
#    my $self = shift;
#    if (($self->content_type || "") !~ m,^multipart/,) {
#	my $p = $self->_part_class->new(
#	    $self->remove_content_headers,
#	    $self->content(""),
#	);
#	$self->content_type("multipart/mixed");
#	$self->{_parts} = [];
#        if ($p->headers->header_field_names || $p->content ne "") {
#            push(@{$self->{_parts}}, $p);
#        }
#    }
#    elsif (!exists $self->{_parts} || ref($self->{_content}) eq "SCALAR") {
#	$self->_parts;
#    }
#
#    push(@{$self->{_parts}}, @_);
#    _stale_content($self);
#    return;
#}
#
#sub _stale_content {
#    my $self = shift;
#    if (ref($self->{_content}) eq "SCALAR") {
#	$self->_content;
#    }
#    else {
#	delete $self->{_content};
#	delete $self->{_content_ref};
#    }
#}
#
#
#our $AUTOLOAD;
#sub AUTOLOAD
#{
#    my $method = substr($AUTOLOAD, rindex($AUTOLOAD, '::')+2);
#
#    no strict 'refs';
#    *$method = sub { local $Carp::Internal{+__PACKAGE__} = 1; shift->headers->$method(@_) };
#    goto &$method;
#}
#
#
#sub DESTROY {}  
#
#
#sub _elem
#{
#    my $self = shift;
#    my $elem = shift;
#    my $old = $self->{$elem};
#    $self->{$elem} = $_[0] if @_;
#    return $old;
#}
#
#
#sub _parts {
#    my $self = shift;
#    my $ct = $self->content_type;
#    if ($ct =~ m,^multipart/,) {
#	require HTTP::Headers::Util;
#	my @h = HTTP::Headers::Util::split_header_words($self->header("Content-Type"));
#	die "Assert" unless @h;
#	my %h = @{$h[0]};
#	if (defined(my $b = $h{boundary})) {
#	    my $str = $self->content;
#	    $str =~ s/\r?\n--\Q$b\E--.*//s;
#	    if ($str =~ s/(^|.*?\r?\n)--\Q$b\E\r?\n//s) {
#		$self->{_parts} = [map $self->_part_class->parse($_),
#				   split(/\r?\n--\Q$b\E\r?\n/, $str)]
#	    }
#	}
#    }
#    elsif ($ct eq "message/http") {
#	require HTTP::Request;
#	require HTTP::Response;
#	my $content = $self->content;
#	my $class = ($content =~ m,^(HTTP/.*)\n,) ?
#	    "HTTP::Response" : "HTTP::Request";
#	$self->{_parts} = [$class->parse($content)];
#    }
#    elsif ($ct =~ m,^message/,) {
#	$self->{_parts} = [ $self->_part_class->parse($self->content) ];
#    }
#
#    $self->{_parts} ||= [];
#}
#
#
#sub _content {
#    my $self = shift;
#    my $ct = $self->{_headers}->header("Content-Type") || "multipart/mixed";
#    if ($ct =~ m,^\s*message/,i) {
#	_set_content($self, $self->{_parts}[0]->as_string($CRLF), 1);
#	return;
#    }
#
#    require HTTP::Headers::Util;
#    my @v = HTTP::Headers::Util::split_header_words($ct);
#    Carp::carp("Multiple Content-Type headers") if @v > 1;
#    @v = @{$v[0]};
#
#    my $boundary;
#    my $boundary_index;
#    for (my @tmp = @v; @tmp;) {
#	my($k, $v) = splice(@tmp, 0, 2);
#	if ($k eq "boundary") {
#	    $boundary = $v;
#	    $boundary_index = @v - @tmp - 1;
#	    last;
#	}
#    }
#
#    my @parts = map $_->as_string($CRLF), @{$self->{_parts}};
#
#    my $bno = 0;
#    $boundary = _boundary() unless defined $boundary;
# CHECK_BOUNDARY:
#    {
#	for (@parts) {
#	    if (index($_, $boundary) >= 0) {
#		$boundary = _boundary(++$bno);
#		redo CHECK_BOUNDARY;
#	    }
#	}
#    }
#
#    if ($boundary_index) {
#	$v[$boundary_index] = $boundary;
#    }
#    else {
#	push(@v, boundary => $boundary);
#    }
#
#    $ct = HTTP::Headers::Util::join_header_words(@v);
#    $self->{_headers}->header("Content-Type", $ct);
#
#    _set_content($self, "--$boundary$CRLF" .
#	                join("$CRLF--$boundary$CRLF", @parts) .
#			"$CRLF--$boundary--$CRLF",
#                        1);
#}
#
#
#sub _boundary
#{
#    my $size = shift || return "xYzZY";
#    require MIME::Base64;
#    my $b = MIME::Base64::encode(join("", map chr(rand(256)), 1..$size*3), "");
#    $b =~ s/[\W]/X/g;  
#    $b;
#}
#
#
#1;
#
#
#__END__
#
### HTTP/Negotiate.pm ###
#package HTTP::Negotiate;
#
#$VERSION = "6.01";
#sub Version { $VERSION; }
#
#require Exporter;
#@ISA = qw(Exporter);
#@EXPORT = qw(choose);
#
#require HTTP::Headers;
#
#$DEBUG = 0;
#
#sub choose ($;$)
#{
#    my($variants, $request) = @_;
#    my(%accept);
#
#    unless (defined $request) {
#	$request = HTTP::Headers->new;
#	$request->header('Accept', $ENV{HTTP_ACCEPT})
#	  if $ENV{HTTP_ACCEPT};
#	$request->header('Accept-Charset', $ENV{HTTP_ACCEPT_CHARSET})
#	  if $ENV{HTTP_ACCEPT_CHARSET};
#	$request->header('Accept-Encoding', $ENV{HTTP_ACCEPT_ENCODING})
#	  if $ENV{HTTP_ACCEPT_ENCODING};
#	$request->header('Accept-Language', $ENV{HTTP_ACCEPT_LANGUAGE})
#	  if $ENV{HTTP_ACCEPT_LANGUAGE};
#    }
#
#
#    $request->scan(sub {
#	my($key, $val) = @_;
#
#	my $type;
#	if ($key =~ s/^Accept-//) {
#	    $type = lc($key);
#	}
#	elsif ($key eq "Accept") {
#	    $type = "type";
#	}
#	else {
#	    return;
#	}
#
#	$val =~ s/\s+//g;
#	my $default_q = 1;
#	for my $name (split(/,/, $val)) {
#	    my(%param, $param);
#	    if ($name =~ s/;(.*)//) {
#		for $param (split(/;/, $1)) {
#		    my ($pk, $pv) = split(/=/, $param, 2);
#		    $param{lc $pk} = $pv;
#		}
#	    }
#	    $name = lc $name;
#	    if (defined $param{'q'}) {
#		$param{'q'} = 1 if $param{'q'} > 1;
#		$param{'q'} = 0 if $param{'q'} < 0;
#	    }
#	    else {
#		$param{'q'} = $default_q;
#
#		$default_q -= 0.0001;
#	    }
#	    $accept{$type}{$name} = \%param;
#	}
#    });
#
#    my $any_lang = 0;
#    for $var (@$variants) {
#	if ($var->[5]) {
#	    $any_lang = 1;
#	    last;
#	}
#    }
#
#    if ($DEBUG) {
#	print "Negotiation parameters in the request\n";
#	for $type (keys %accept) {
#	    print " $type:\n";
#	    for $name (keys %{$accept{$type}}) {
#		print "    $name\n";
#		for $pv (keys %{$accept{$type}{$name}}) {
#		    print "      $pv = $accept{$type}{$name}{$pv}\n";
#		}
#	    }
#	}
#    }
#
#    my @Q = ();  
#
#    for (@$variants) {
#	my($id, $qs, $ct, $enc, $cs, $lang, $bs) = @$_;
#	$qs = 1 unless defined $qs;
#        $ct = '' unless defined $ct;
#	$bs = 0 unless defined $bs;
#	$lang = lc($lang) if $lang; 
#	if ($DEBUG) {
#	    print "\nEvaluating $id (ct='$ct')\n";
#	    printf "  qs   = %.3f\n", $qs;
#	    print  "  enc  = $enc\n"  if $enc && !ref($enc);
#	    print  "  enc  = @$enc\n" if $enc && ref($enc);
#	    print  "  cs   = $cs\n"   if $cs;
#	    print  "  lang = $lang\n" if $lang;
#	    print  "  bs   = $bs\n"   if $bs;
#	}
#
#	my $qe = 1;
#	if (exists $accept{'encoding'} && $enc) {
#	    my @enc = ref($enc) ? @$enc : ($enc);
#	    for (@enc) {
#		print "Is encoding $_ accepted? " if $DEBUG;
#		unless(exists $accept{'encoding'}{$_}) {
#		    print "no\n" if $DEBUG;
#		    $qe = 0;
#		    last;
#		}
#		else {
#		    print "yes\n" if $DEBUG;
#		}
#	    }
#	}
#
#	my $qc  = 1;
#	if (exists $accept{'charset'} && $cs && $cs ne 'us-ascii' ) {
#	    $qc = 0 unless $accept{'charset'}{$cs};
#	}
#
#	my $ql  = 1;
#	if ($lang && exists $accept{'language'}) {
#	    my @lang = ref($lang) ? @$lang : ($lang);
#	    my $q = undef;
#	    for (@lang) {
#		next unless exists $accept{'language'}{$_};
#		my $this_q = $accept{'language'}{$_}{'q'};
#		$q = $this_q unless defined $q;
#		$q = $this_q if $this_q > $q;
#	    }
#	    if(defined $q) {
#	        $DEBUG and print " -- Exact language match at q=$q\n";
#	    }
#	    else {
#		$DEBUG and print " -- No exact language match\n";
#		my $selected = undef;
#		for $al (keys %{ $accept{'language'} }) {
#		    if (index($al, "$lang-") == 0) {
#		        $DEBUG and print " -- $al ISA $lang\n";
#			$selected = $al unless defined $selected;
#			$selected = $al if length($al) > length($selected);
#		    }
#		    else {
#		        $DEBUG and print " -- $lang  isn't a $al\n";
#		    }
#		}
#		$q = $accept{'language'}{$selected}{'q'} if $selected;
#
#		$q = 0.001 unless defined $q;
#	    }
#	    $ql = $q;
#	}
#	else {
#	    $ql = 0.5 if $any_lang && exists $accept{'language'};
#	}
#
#	my $q   = 1;
#	my $mbx = undef;
#	if (exists $accept{'type'} && $ct) {
#	    $ct =~ s/\s+//g;
#	    my $params = "";
#	    $params = $1 if $ct =~ s/;(.*)//;
#	    my($type, $subtype) = split("/", $ct, 2);
#	    my %param = ();
#	    for $param (split(/;/, $params)) {
#		my($pk,$pv) = split(/=/, $param, 2);
#		$param{$pk} = $pv;
#	    }
#
#	    my $sel_q = undef;
#	    my $sel_mbx = undef;
#	    my $sel_specificness = 0;
#
#	    ACCEPT_TYPE:
#	    for $at (keys %{ $accept{'type'} }) {
#		print "Consider $at...\n" if $DEBUG;
#		my($at_type, $at_subtype) = split("/", $at, 2);
#		next if $at_type    ne '*' && $at_type    ne $type;
#		next if $at_subtype ne '*' && $at_subtype ne $subtype;
#		my $specificness = 0;
#		$specificness++ if $at_type ne '*';
#		$specificness++ if $at_subtype ne '*';
#		while (($pk, $pv) = each %param) {
#		    print "Check if $pk = $pv is true\n" if $DEBUG;
#		    next unless exists $accept{'type'}{$at}{$pk};
#		    next ACCEPT_TYPE
#		      unless $accept{'type'}{$at}{$pk} eq $pv;
#		    print "yes it is!!\n" if $DEBUG;
#		    $specificness++;
#		}
#		print "Hurray, type match with specificness = $specificness\n"
#		  if $DEBUG;
#
#		if (!defined($sel_q) || $sel_specificness < $specificness) {
#		    $sel_q   = $accept{'type'}{$at}{'q'};
#		    $sel_mbx = $accept{'type'}{$at}{'mbx'};
#		    $sel_specificness = $specificness;
#		}
#	    }
#	    $q   = $sel_q || 0;
#	    $mbx = $sel_mbx;
#	}
#
#	my $Q;
#	if (!defined($mbx) || $mbx >= $bs) {
#	    $Q = $qs * $qe * $qc * $ql * $q;
#	}
#	else {
#	    $Q = 0;
#	    print "Variant's size is too large ==> Q=0\n" if $DEBUG;
#	}
#
#	if ($DEBUG) {
#	    $mbx = "undef" unless defined $mbx;
#	    printf "Q=%.4f", $Q;
#	    print "  (q=$q, mbx=$mbx, qe=$qe, qc=$qc, ql=$ql, qs=$qs)\n";
#	}
#
#	push(@Q, [$id, $Q, $bs]);
#    }
#
#
#    @Q = sort { $b->[1] <=> $a->[1] || $a->[2] <=> $b->[2] } @Q;
#
#    return @Q if wantarray;
#    return undef unless @Q;
#    return undef if $Q[0][1] == 0;
#    $Q[0][0];
#}
#
#1;
#
#__END__
#
#
### HTTP/Request.pm ###
#package HTTP::Request;
#
#use strict;
#use warnings;
#
#use base 'HTTP::Message';
#
#our $VERSION = "6.11";
#
#sub new
#{
#    my($class, $method, $uri, $header, $content) = @_;
#    my $self = $class->SUPER::new($header, $content);
#    $self->method($method);
#    $self->uri($uri);
#    $self;
#}
#
#
#sub parse
#{
#    my($class, $str) = @_;
#    my $request_line;
#    if ($str =~ s/^(.*)\n//) {
#	$request_line = $1;
#    }
#    else {
#	$request_line = $str;
#	$str = "";
#    }
#
#    my $self = $class->SUPER::parse($str);
#    my($method, $uri, $protocol) = split(' ', $request_line);
#    $self->method($method) if defined($method);
#    $self->uri($uri) if defined($uri);
#    $self->protocol($protocol) if $protocol;
#    $self;
#}
#
#
#sub clone
#{
#    my $self = shift;
#    my $clone = bless $self->SUPER::clone, ref($self);
#    $clone->method($self->method);
#    $clone->uri($self->uri);
#    $clone;
#}
#
#
#sub method
#{
#    shift->_elem('_method', @_);
#}
#
#
#sub uri
#{
#    my $self = shift;
#    my $old = $self->{'_uri'};
#    if (@_) {
#	my $uri = shift;
#	if (!defined $uri) {
#	}
#	elsif (ref $uri) {
#	    Carp::croak("A URI can't be a " . ref($uri) . " reference")
#		if ref($uri) eq 'HASH' or ref($uri) eq 'ARRAY';
#	    Carp::croak("Can't use a " . ref($uri) . " object as a URI")
#		unless $uri->can('scheme');
#	    $uri = $uri->clone;
#	    unless ($HTTP::URI_CLASS eq "URI") {
#		eval { local $SIG{__DIE__}; $uri = $uri->abs; };
#		die $@ if $@ && $@ !~ /Missing base argument/;
#	    }
#	}
#	else {
#	    $uri = $HTTP::URI_CLASS->new($uri);
#	}
#	$self->{'_uri'} = $uri;
#        delete $self->{'_uri_canonical'};
#    }
#    $old;
#}
#
#*url = \&uri;  
#
#sub uri_canonical
#{
#    my $self = shift;
#    return $self->{'_uri_canonical'} ||= $self->{'_uri'}->canonical;
#}
#
#
#sub accept_decodable
#{
#    my $self = shift;
#    $self->header("Accept-Encoding", scalar($self->decodable));
#}
#
#sub as_string
#{
#    my $self = shift;
#    my($eol) = @_;
#    $eol = "\n" unless defined $eol;
#
#    my $req_line = $self->method || "-";
#    my $uri = $self->uri;
#    $uri = (defined $uri) ? $uri->as_string : "-";
#    $req_line .= " $uri";
#    my $proto = $self->protocol;
#    $req_line .= " $proto" if $proto;
#
#    return join($eol, $req_line, $self->SUPER::as_string(@_));
#}
#
#sub dump
#{
#    my $self = shift;
#    my @pre = ($self->method || "-", $self->uri || "-");
#    if (my $prot = $self->protocol) {
#	push(@pre, $prot);
#    }
#
#    return $self->SUPER::dump(
#        preheader => join(" ", @pre),
#	@_,
#    );
#}
#
#
#1;
#
#__END__
#
### HTTP/Request/Common.pm ###
#package HTTP::Request::Common;
#
#use strict;
#use warnings;
#
#our $DYNAMIC_FILE_UPLOAD ||= 0;  
#
#use Exporter 5.57 'import';
#
#our @EXPORT =qw(GET HEAD PUT POST);
#our @EXPORT_OK = qw($DYNAMIC_FILE_UPLOAD DELETE);
#
#require HTTP::Request;
#use Carp();
#
#our $VERSION = "6.11";
#
#my $CRLF = "\015\012";   
#
#sub GET  { _simple_req('GET',  @_); }
#sub HEAD { _simple_req('HEAD', @_); }
#sub DELETE { _simple_req('DELETE', @_); }
#
#for my $type (qw(PUT POST)) {
#    no strict 'refs';
#    *{ __PACKAGE__ . "::" . $type } = sub {
#        return request_type_with_data($type, @_);
#    };
#}
#
#sub request_type_with_data
#{
#    my $type = shift;
#    my $url  = shift;
#    my $req = HTTP::Request->new($type => $url);
#    my $content;
#    $content = shift if @_ and ref $_[0];
#    my($k, $v);
#    while (($k,$v) = splice(@_, 0, 2)) {
#	if (lc($k) eq 'content') {
#	    $content = $v;
#	}
#	else {
#	    $req->push_header($k, $v);
#	}
#    }
#    my $ct = $req->header('Content-Type');
#    unless ($ct) {
#	$ct = 'application/x-www-form-urlencoded';
#    }
#    elsif ($ct eq 'form-data') {
#	$ct = 'multipart/form-data';
#    }
#
#    if (ref $content) {
#	if ($ct =~ m,^multipart/form-data\s*(;|$),i) {
#	    require HTTP::Headers::Util;
#	    my @v = HTTP::Headers::Util::split_header_words($ct);
#	    Carp::carp("Multiple Content-Type headers") if @v > 1;
#	    @v = @{$v[0]};
#
#	    my $boundary;
#	    my $boundary_index;
#	    for (my @tmp = @v; @tmp;) {
#		my($k, $v) = splice(@tmp, 0, 2);
#		if ($k eq "boundary") {
#		    $boundary = $v;
#		    $boundary_index = @v - @tmp - 1;
#		    last;
#		}
#	    }
#
#	    ($content, $boundary) = form_data($content, $boundary, $req);
#
#	    if ($boundary_index) {
#		$v[$boundary_index] = $boundary;
#	    }
#	    else {
#		push(@v, boundary => $boundary);
#	    }
#
#	    $ct = HTTP::Headers::Util::join_header_words(@v);
#	}
#	else {
#	    require URI;
#	    my $url = URI->new('http:');
#	    $url->query_form(ref($content) eq "HASH" ? %$content : @$content);
#	    $content = $url->query;
#
#	    $content =~ s/(?<!%0D)%0A/%0D%0A/g if defined($content);
#	}
#    }
#
#    $req->header('Content-Type' => $ct);  
#    if (defined($content)) {
#	$req->header('Content-Length' =>
#		     length($content)) unless ref($content);
#	$req->content($content);
#    }
#    else {
#        $req->header('Content-Length' => 0);
#    }
#    $req;
#}
#
#
#sub _simple_req
#{
#    my($method, $url) = splice(@_, 0, 2);
#    my $req = HTTP::Request->new($method => $url);
#    my($k, $v);
#    my $content;
#    while (($k,$v) = splice(@_, 0, 2)) {
#	if (lc($k) eq 'content') {
#	    $req->add_content($v);
#            $content++;
#	}
#	else {
#	    $req->push_header($k, $v);
#	}
#    }
#    if ($content && !defined($req->header("Content-Length"))) {
#        $req->header("Content-Length", length(${$req->content_ref}));
#    }
#    $req;
#}
#
#
#sub form_data   
#{
#    my($data, $boundary, $req) = @_;
#    my @data = ref($data) eq "HASH" ? %$data : @$data;  
#    my $fhparts;
#    my @parts;
#    while (my ($k,$v) = splice(@data, 0, 2)) {
#	if (!ref($v)) {
#	    $k =~ s/([\\\"])/\\$1/g;  
#            no warnings 'uninitialized';
#	    push(@parts,
#		 qq(Content-Disposition: form-data; name="$k"$CRLF$CRLF$v));
#	}
#	else {
#	    my($file, $usename, @headers) = @$v;
#	    unless (defined $usename) {
#		$usename = $file;
#		$usename =~ s,.*/,, if defined($usename);
#	    }
#            $k =~ s/([\\\"])/\\$1/g;
#	    my $disp = qq(form-data; name="$k");
#            if (defined($usename) and length($usename)) {
#                $usename =~ s/([\\\"])/\\$1/g;
#                $disp .= qq(; filename="$usename");
#            }
#	    my $content = "";
#	    my $h = HTTP::Headers->new(@headers);
#	    if ($file) {
#		open(my $fh, "<", $file) or Carp::croak("Can't open file $file: $!");
#		binmode($fh);
#		if ($DYNAMIC_FILE_UPLOAD) {
#                    close($fh);
#		    $content = \$file;
#		}
#		else {
#		    local($/) = undef; 
#		    $content = <$fh>;
#		    close($fh);
#		}
#		unless ($h->header("Content-Type")) {
#		    require LWP::MediaTypes;
#		    LWP::MediaTypes::guess_media_type($file, $h);
#		}
#	    }
#	    if ($h->header("Content-Disposition")) {
#		$disp = $h->header("Content-Disposition");
#		$h->remove_header("Content-Disposition");
#	    }
#	    if ($h->header("Content")) {
#		$content = $h->header("Content");
#		$h->remove_header("Content");
#	    }
#	    my $head = join($CRLF, "Content-Disposition: $disp",
#			           $h->as_string($CRLF),
#			           "");
#	    if (ref $content) {
#		push(@parts, [$head, $$content]);
#		$fhparts++;
#	    }
#	    else {
#		push(@parts, $head . $content);
#	    }
#	}
#    }
#    return ("", "none") unless @parts;
#
#    my $content;
#    if ($fhparts) {
#	$boundary = boundary(10) 
#	    unless $boundary;
#
#	for (1..@parts-1) {
#	    splice(@parts, $_*2-1, 0, "$CRLF--$boundary$CRLF");
#	}
#	unshift(@parts, "--$boundary$CRLF");
#	push(@parts, "$CRLF--$boundary--$CRLF");
#
#	my $length = 0;
#	for (@parts) {
#	    if (ref $_) {
#	 	my ($head, $f) = @$_;
#		my $file_size;
#		unless ( -f $f && ($file_size = -s _) ) {
#		    undef $length;
#		    last;
#		}
#	    	$length += $file_size + length $head;
#	    }
#	    else {
#		$length += length;
#	    }
#        }
#        $length && $req->header('Content-Length' => $length);
#
#	$content = sub {
#	    for (;;) {
#		unless (@parts) {
#		    defined $length && $length != 0 &&
#		    	Carp::croak "length of data sent did not match calculated Content-Length header.  Probably because uploaded file changed in size during transfer.";
#		    return;
#		}
#		my $p = shift @parts;
#		unless (ref $p) {
#		    $p .= shift @parts while @parts && !ref($parts[0]);
#		    defined $length && ($length -= length $p);
#		    return $p;
#		}
#		my($buf, $fh) = @$p;
#                unless (ref($fh)) {
#                    my $file = $fh;
#                    undef($fh);
#                    open($fh, "<", $file) || Carp::croak("Can't open file $file: $!");
#                    binmode($fh);
#                }
#		my $buflength = length $buf;
#		my $n = read($fh, $buf, 2048, $buflength);
#		if ($n) {
#		    $buflength += $n;
#		    unshift(@parts, ["", $fh]);
#		}
#		else {
#		    close($fh);
#		}
#		if ($buflength) {
#		    defined $length && ($length -= $buflength);
#		    return $buf 
#	    	}
#	    }
#	};
#
#    }
#    else {
#	$boundary = boundary() unless $boundary;
#
#	my $bno = 0;
#      CHECK_BOUNDARY:
#	{
#	    for (@parts) {
#		if (index($_, $boundary) >= 0) {
#		    $boundary = boundary(++$bno);
#		    redo CHECK_BOUNDARY;
#		}
#	    }
#	    last;
#	}
#	$content = "--$boundary$CRLF" .
#	           join("$CRLF--$boundary$CRLF", @parts) .
#		   "$CRLF--$boundary--$CRLF";
#    }
#
#    wantarray ? ($content, $boundary) : $content;
#}
#
#
#sub boundary
#{
#    my $size = shift || return "xYzZY";
#    require MIME::Base64;
#    my $b = MIME::Base64::encode(join("", map chr(rand(256)), 1..$size*3), "");
#    $b =~ s/[\W]/X/g;  
#    $b;
#}
#
#1;
#
#__END__
#
#
### HTTP/Response.pm ###
#package HTTP::Response;
#
#use strict;
#use warnings;
#
#use base 'HTTP::Message';
#
#our $VERSION = "6.11";
#
#use HTTP::Status ();
#
#
#sub new
#{
#    my($class, $rc, $msg, $header, $content) = @_;
#    my $self = $class->SUPER::new($header, $content);
#    $self->code($rc);
#    $self->message($msg);
#    $self;
#}
#
#
#sub parse
#{
#    my($class, $str) = @_;
#    my $status_line;
#    if ($str =~ s/^(.*)\n//) {
#	$status_line = $1;
#    }
#    else {
#	$status_line = $str;
#	$str = "";
#    }
#
#    my $self = $class->SUPER::parse($str);
#    my($protocol, $code, $message);
#    if ($status_line =~ /^\d{3} /) {
#       ($code, $message) = split(' ', $status_line, 2);
#    } else {
#       ($protocol, $code, $message) = split(' ', $status_line, 3);
#    }
#    $self->protocol($protocol) if $protocol;
#    $self->code($code) if defined($code);
#    $self->message($message) if defined($message);
#    $self;
#}
#
#
#sub clone
#{
#    my $self = shift;
#    my $clone = bless $self->SUPER::clone, ref($self);
#    $clone->code($self->code);
#    $clone->message($self->message);
#    $clone->request($self->request->clone) if $self->request;
#    $clone;
#}
#
#
#sub code      { shift->_elem('_rc',      @_); }
#sub message   { shift->_elem('_msg',     @_); }
#sub previous  { shift->_elem('_previous',@_); }
#sub request   { shift->_elem('_request', @_); }
#
#
#sub status_line
#{
#    my $self = shift;
#    my $code = $self->{'_rc'}  || "000";
#    my $mess = $self->{'_msg'} || HTTP::Status::status_message($code) || "Unknown code";
#    return "$code $mess";
#}
#
#
#sub base
#{
#    my $self = shift;
#    my $base = (
#	$self->header('Content-Base'),        
#	$self->header('Content-Location'),    
#	$self->header('Base'),                
#    )[0];
#    if ($base && $base =~ /^$URI::scheme_re:/o) {
#	return $HTTP::URI_CLASS->new($base);
#    }
#
#    my $req = $self->request;
#    if ($req) {
#        return $HTTP::URI_CLASS->new_abs($base, $req->uri);
#    }
#
#    return undef;
#}
#
#
#sub redirects {
#    my $self = shift;
#    my @r;
#    my $r = $self;
#    while (my $p = $r->previous) {
#        push(@r, $p);
#        $r = $p;
#    }
#    return @r unless wantarray;
#    return reverse @r;
#}
#
#
#sub filename
#{
#    my $self = shift;
#    my $file;
#
#    my $cd = $self->header('Content-Disposition');
#    if ($cd) {
#	require HTTP::Headers::Util;
#	if (my @cd = HTTP::Headers::Util::split_header_words($cd)) {
#	    my ($disposition, undef, %cd_param) = @{$cd[-1]};
#	    $file = $cd_param{filename};
#
#	    if ($file && $file =~ /^=\?(.+?)\?(.+?)\?(.+)\?=$/) {
#		my $charset = $1;
#		my $encoding = uc($2);
#		my $encfile = $3;
#
#		if ($encoding eq 'Q' || $encoding eq 'B') {
#		    local($SIG{__DIE__});
#		    eval {
#			if ($encoding eq 'Q') {
#			    $encfile =~ s/_/ /g;
#			    require MIME::QuotedPrint;
#			    $encfile = MIME::QuotedPrint::decode($encfile);
#			}
#			else { 
#			    require MIME::Base64;
#			    $encfile = MIME::Base64::decode($encfile);
#			}
#
#			require Encode;
#			require Encode::Locale;
#			Encode::from_to($encfile, $charset, "locale_fs");
#		    };
#
#		    $file = $encfile unless $@;
#		}
#	    }
#	}
#    }
#
#    unless (defined($file) && length($file)) {
#	my $uri;
#	if (my $cl = $self->header('Content-Location')) {
#	    $uri = URI->new($cl);
#	}
#	elsif (my $request = $self->request) {
#	    $uri = $request->uri;
#	}
#
#	if ($uri) {
#	    $file = ($uri->path_segments)[-1];
#	}
#    }
#
#    if ($file) {
#	$file =~ s,.*[\\/],,;  
#    }
#
#    if ($file && !length($file)) {
#	$file = undef;
#    }
#
#    $file;
#}
#
#
#sub as_string
#{
#    my $self = shift;
#    my($eol) = @_;
#    $eol = "\n" unless defined $eol;
#
#    my $status_line = $self->status_line;
#    my $proto = $self->protocol;
#    $status_line = "$proto $status_line" if $proto;
#
#    return join($eol, $status_line, $self->SUPER::as_string(@_));
#}
#
#
#sub dump
#{
#    my $self = shift;
#
#    my $status_line = $self->status_line;
#    my $proto = $self->protocol;
#    $status_line = "$proto $status_line" if $proto;
#
#    return $self->SUPER::dump(
#	preheader => $status_line,
#        @_,
#    );
#}
#
#
#sub is_info     { HTTP::Status::is_info     (shift->{'_rc'}); }
#sub is_success  { HTTP::Status::is_success  (shift->{'_rc'}); }
#sub is_redirect { HTTP::Status::is_redirect (shift->{'_rc'}); }
#sub is_error    { HTTP::Status::is_error    (shift->{'_rc'}); }
#sub is_client_error { HTTP::Status::is_client_error (shift->{'_rc'}); }
#sub is_server_error { HTTP::Status::is_server_error (shift->{'_rc'}); }
#
#
#sub error_as_HTML
#{
#    my $self = shift;
#    my $title = 'An Error Occurred';
#    my $body  = $self->status_line;
#    $body =~ s/&/&amp;/g;
#    $body =~ s/</&lt;/g;
#    return <<EOM;
#<html>
#<head><title>$title</title></head>
#<body>
#<h1>$title</h1>
#<p>$body</p>
#</body>
#</html>
#EOM
#}
#
#
#sub current_age
#{
#    my $self = shift;
#    my $time = shift;
#
#    my $response_time = $self->client_date;
#    my $date = $self->date;
#
#    my $age = 0;
#    if ($response_time && $date) {
#	$age = $response_time - $date;  
#	$age = 0 if $age < 0;
#    }
#
#    my $age_v = $self->header('Age');
#    if ($age_v && $age_v > $age) {
#	$age = $age_v;   
#    }
#
#    if ($response_time) {
#	my $request = $self->request;
#	if ($request) {
#	    my $request_time = $request->date;
#	    if ($request_time && $request_time < $response_time) {
#		$age += $response_time - $request_time;
#	    }
#	}
#	$age += ($time || time) - $response_time;
#    }
#    return $age;
#}
#
#
#sub freshness_lifetime
#{
#    my($self, %opt) = @_;
#
#    for my $cc ($self->header('Cache-Control')) {
#	for my $cc_dir (split(/\s*,\s*/, $cc)) {
#	    return $1 if $cc_dir =~ /^max-age\s*=\s*(\d+)/i;
#	}
#    }
#
#    my $date = $self->date || $self->client_date || $opt{time} || time;
#    if (my $expires = $self->expires) {
#	return $expires - $date;
#    }
#
#    return undef if exists $opt{heuristic_expiry} && !$opt{heuristic_expiry};
#
#    $opt{h_min} ||= 60;
#    $opt{h_max} ||= 24 * 3600;
#    $opt{h_lastmod_fraction} ||= 0.10; 
#    $opt{h_default} ||= 3600;
#
#
#    if (my $last_modified = $self->last_modified) {
#	my $h_exp = ($date - $last_modified) * $opt{h_lastmod_fraction};
#	return $opt{h_min} if $h_exp < $opt{h_min};
#	return $opt{h_max} if $h_exp > $opt{h_max};
#	return $h_exp;
#    }
#
#    return $opt{h_min} if $opt{h_min} > $opt{h_default};
#    return $opt{h_default};
#}
#
#
#sub is_fresh
#{
#    my($self, %opt) = @_;
#    $opt{time} ||= time;
#    my $f = $self->freshness_lifetime(%opt);
#    return undef unless defined($f);
#    return $f > $self->current_age($opt{time});
#}
#
#
#sub fresh_until
#{
#    my($self, %opt) = @_;
#    $opt{time} ||= time;
#    my $f = $self->freshness_lifetime(%opt);
#    return undef unless defined($f);
#    return $f - $self->current_age($opt{time}) + $opt{time};
#}
#
#1;
#
#
#__END__
#
### HTTP/Status.pm ###
#package HTTP::Status;
#
#use strict;
#use warnings;
#
#require 5.002;   
#
#use base 'Exporter';
#our @EXPORT = qw(is_info is_success is_redirect is_error status_message);
#our @EXPORT_OK = qw(is_client_error is_server_error);
#
#our $VERSION = "6.11";
#
#
#
#my %StatusCode = (
#    100 => 'Continue',
#    101 => 'Switching Protocols',
#    102 => 'Processing',                      
#    200 => 'OK',
#    201 => 'Created',
#    202 => 'Accepted',
#    203 => 'Non-Authoritative Information',
#    204 => 'No Content',
#    205 => 'Reset Content',
#    206 => 'Partial Content',
#    207 => 'Multi-Status',                    
#    208 => 'Already Reported',		      
#    300 => 'Multiple Choices',
#    301 => 'Moved Permanently',
#    302 => 'Found',
#    303 => 'See Other',
#    304 => 'Not Modified',
#    305 => 'Use Proxy',
#    307 => 'Temporary Redirect',
#    308 => 'Permanent Redirect',              
#    400 => 'Bad Request',
#    401 => 'Unauthorized',
#    402 => 'Payment Required',
#    403 => 'Forbidden',
#    404 => 'Not Found',
#    405 => 'Method Not Allowed',
#    406 => 'Not Acceptable',
#    407 => 'Proxy Authentication Required',
#    408 => 'Request Timeout',
#    409 => 'Conflict',
#    410 => 'Gone',
#    411 => 'Length Required',
#    412 => 'Precondition Failed',
#    413 => 'Request Entity Too Large',
#    414 => 'Request-URI Too Large',
#    415 => 'Unsupported Media Type',
#    416 => 'Request Range Not Satisfiable',
#    417 => 'Expectation Failed',
#    418 => 'I\'m a teapot',		      
#    422 => 'Unprocessable Entity',            
#    423 => 'Locked',                          
#    424 => 'Failed Dependency',               
#    425 => 'No code',                         
#    426 => 'Upgrade Required',                
#    428 => 'Precondition Required',
#    429 => 'Too Many Requests',
#    431 => 'Request Header Fields Too Large',
#    449 => 'Retry with',                      
#    500 => 'Internal Server Error',
#    501 => 'Not Implemented',
#    502 => 'Bad Gateway',
#    503 => 'Service Unavailable',
#    504 => 'Gateway Timeout',
#    505 => 'HTTP Version Not Supported',
#    506 => 'Variant Also Negotiates',         
#    507 => 'Insufficient Storage',            
#    509 => 'Bandwidth Limit Exceeded',        
#    510 => 'Not Extended',                    
#    511 => 'Network Authentication Required',
#);
#
#my $mnemonicCode = '';
#my ($code, $message);
#while (($code, $message) = each %StatusCode) {
#    $message =~ s/I'm/I am/;
#    $message =~ tr/a-z \-/A-Z__/;
#    $mnemonicCode .= "sub HTTP_$message () { $code }\n";
#    $mnemonicCode .= "*RC_$message = \\&HTTP_$message;\n";  
#    $mnemonicCode .= "push(\@EXPORT_OK, 'HTTP_$message');\n";
#    $mnemonicCode .= "push(\@EXPORT, 'RC_$message');\n";
#}
#eval $mnemonicCode; 
#die if $@;
#
#*RC_MOVED_TEMPORARILY = \&RC_FOUND;  
#push(@EXPORT, "RC_MOVED_TEMPORARILY");
#
#our %EXPORT_TAGS = (
#   constants => [grep /^HTTP_/, @EXPORT_OK],
#   is => [grep /^is_/, @EXPORT, @EXPORT_OK],
#);
#
#
#sub status_message  ($) { $StatusCode{$_[0]}; }
#
#sub is_info         ($) { $_[0] >= 100 && $_[0] < 200; }
#sub is_success      ($) { $_[0] >= 200 && $_[0] < 300; }
#sub is_redirect     ($) { $_[0] >= 300 && $_[0] < 400; }
#sub is_error        ($) { $_[0] >= 400 && $_[0] < 600; }
#sub is_client_error ($) { $_[0] >= 400 && $_[0] < 500; }
#sub is_server_error ($) { $_[0] >= 500 && $_[0] < 600; }
#
#1;
#
#
#__END__
#
### HTTP/Tiny.pm ###
#package HTTP::Tiny;
#use strict;
#use warnings;
#
#our $VERSION = '0.056';
#
#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) );
#}
#
#
#sub can_ssl {
#    my ($self) = @_;
#
#    my($ok, $reason) = (1, '');
#
#    unless (eval {require IO::Socket::SSL; IO::Socket::SSL->VERSION(1.42)}) {
#        $ok = 0;
#        $reason .= qq/IO::Socket::SSL 1.42 must be installed for https support\n/;
#    }
#
#    unless (eval {require Net::SSLeay; Net::SSLeay->VERSION(1.49)}) {
#        $ok = 0;
#        $reason .= qq/Net::SSLeay 1.49 must be installed for https support\n/;
#    }
#
#    if ( ref($self) && ( $self->{verify_SSL} || $self->{SSL_options}{SSL_verify_mode} ) ) {
#        my $handle = HTTP::Tiny::Handle->new(
#            SSL_options => $self->{SSL_options},
#            verify_SSL  => $self->{verify_SSL},
#        );
#        unless ( eval { $handle->_find_CA_file; 1 } ) {
#            $ok = 0;
#            $reason .= "$@";
#        }
#    }
#
#    wantarray ? ($ok, $reason) : $ok;
#}
#
#
#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[1278]/ && $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 {
#    my($ok, $reason) = HTTP::Tiny->can_ssl();
#    die $reason unless $ok;
#}
#
#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();
#
#    if ( $self->{SSL_options}->{SSL_ca_file} ) {
#        unless ( -r $self->{SSL_options}->{SSL_ca_file} ) {
#            die qq/SSL_ca_file '$self->{SSL_options}->{SSL_ca_file}' not found or not readable\n/;
#        }
#        return $self->{SSL_options}->{SSL_ca_file};
#    }
#
#    return Mozilla::CA::SSL_ca_file()
#        if eval { require Mozilla::CA; 1 };
#
#    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/HTML.pm ###
#package IO::HTML;
#
#use 5.008;
#use strict;
#use warnings;
#
#use Carp 'croak';
#use Encode 2.10 qw(decode find_encoding); 
#use Exporter 5.57 'import';
#
#our $VERSION = '1.001';
#
#our $default_encoding ||= 'cp1252';
#
#our @EXPORT    = qw(html_file);
#our @EXPORT_OK = qw(find_charset_in html_file_and_encoding html_outfile
#                    sniff_encoding);
#
#our %EXPORT_TAGS = (
#  rw  => [qw( html_file html_file_and_encoding html_outfile )],
#  all => [ @EXPORT, @EXPORT_OK ],
#);
#
#
#
#sub html_file
#{
#  (&html_file_and_encoding)[0]; 
#} 
#
#
#
#sub html_file_and_encoding
#{
#  my ($filename, $options) = @_;
#
#  $options ||= {};
#
#  open(my $in, '<:raw', $filename) or croak "Failed to open $filename: $!";
#
#
#  my ($encoding, $bom) = sniff_encoding($in, $filename, $options);
#
#  if (not defined $encoding) {
#    croak "No default encoding specified"
#        unless defined($encoding = $default_encoding);
#    $encoding = find_encoding($encoding) if $options->{encoding};
#  } 
#
#  binmode $in, sprintf(":encoding(%s):crlf",
#                       $options->{encoding} ? $encoding->name : $encoding);
#
#  return ($in, $encoding, $bom);
#} 
#
#
#sub html_outfile
#{
#  my ($filename, $encoding, $bom) = @_;
#
#  if (not defined $encoding) {
#    croak "No default encoding specified"
#        unless defined($encoding = $default_encoding);
#  } 
#  elsif (ref $encoding) {
#    $encoding = $encoding->name;
#  }
#
#  open(my $out, ">:encoding($encoding)", $filename)
#      or croak "Failed to open $filename: $!";
#
#  print $out "\x{FeFF}" if $bom;
#
#  return $out;
#} 
#
#
#sub sniff_encoding
#{
#  my ($in, $filename, $options) = @_;
#
#  $filename = 'file' unless defined $filename;
#  $options ||= {};
#
#  my $pos = tell $in;
#  croak "Could not seek $filename: $!" if $pos < 0;
#
#  croak "Could not read $filename: $!" unless defined read $in, my $buf, 1024;
#
#  seek $in, $pos, 0 or croak "Could not seek $filename: $!";
#
#
#  my $bom;
#  my $encoding = do {
#    if ($buf =~ /^\xFe\xFF/) {
#      $bom = 2;
#      'UTF-16BE';
#    } elsif ($buf =~ /^\xFF\xFe/) {
#      $bom = 2;
#      'UTF-16LE';
#    } elsif ($buf =~ /^\xEF\xBB\xBF/) {
#      $bom = 3;
#      'utf-8-strict';
#    } else {
#      find_charset_in($buf, $options); 
#    }
#  }; 
#
#  if ($bom) {
#    seek $in, $bom, 1 or croak "Could not seek $filename: $!";
#    $bom = 1;
#  }
#  elsif (not defined $encoding) { 
#    my $test = decode('utf-8-strict', $buf, Encode::FB_QUIET);
#    if ($buf =~ /^(?:                   # nothing left over
#         | [\xC2-\xDF]                  # incomplete 2-byte char
#         | [\xE0-\xEF] [\x80-\xBF]?     # incomplete 3-byte char
#         | [\xF0-\xF4] [\x80-\xBF]{0,2} # incomplete 4-byte char
#        )\z/x and $test =~ /[^\x00-\x7F]/) {
#      $encoding = 'utf-8-strict';
#    } 
#  } 
#
#  if (defined $encoding and $options->{encoding} and not ref $encoding) {
#    $encoding = find_encoding($encoding);
#  } 
#
#  return wantarray ? ($encoding, $bom) : $encoding;
#} 
#
#
#sub _get_attribute
#{
#  m!\G[\x09\x0A\x0C\x0D /]+!gc; 
#
#  return if /\G>/gc or not /\G(=?[^\x09\x0A\x0C\x0D =]*)/gc;
#
#  my ($name, $value) = (lc $1, '');
#
#  if (/\G[\x09\x0A\x0C\x0D ]*=[\x09\x0A\x0C\x0D ]*/gc
#      and (/\G"([^"]*)"?/gc or
#           /\G'([^']*)'?/gc or
#           /\G([^\x09\x0A\x0C\x0D >]*)/gc)) {
#    $value = lc $1;
#  } 
#
#  return wantarray ? ($name, $value) : 1;
#} 
#
#sub _get_charset_from_meta
#{
#  for (shift) {
#    while (/charset[\x09\x0A\x0C\x0D ]*=[\x09\x0A\x0C\x0D ]*/ig) {
#      return $1 if (/\G"([^"]*)"/gc or
#                    /\G'([^']*)'/gc or
#                    /\G(?!['"])([^\x09\x0A\x0C\x0D ;]+)/gc);
#    }
#  } 
#
#  return undef;
#} 
#
#
#sub find_charset_in
#{
#  for (shift) {
#    my $options = shift || {};
#    my $stop = length > 1024 ? 1024 : length; 
#
#    my $expect_pragma = (defined $options->{need_pragma}
#                         ? $options->{need_pragma} : 1);
#
#    pos() = 0;
#    while (pos() < $stop) {
#      if (/\G<!--.*?(?<=--)>/sgc) {
#      } 
#      elsif (m!\G<meta(?=[\x09\x0A\x0C\x0D /])!gic) {
#        my ($got_pragma, $need_pragma, $charset);
#
#        while (my ($name, $value) = &_get_attribute) {
#          if ($name eq 'http-equiv' and $value eq 'content-type') {
#            $got_pragma = 1;
#          } elsif ($name eq 'content' and not defined $charset) {
#            $need_pragma = $expect_pragma
#                if defined($charset = _get_charset_from_meta($value));
#          } elsif ($name eq 'charset') {
#            $charset = $value;
#            $need_pragma = 0;
#          }
#        } 
#
#        if (defined $need_pragma and (not $need_pragma or $got_pragma)) {
#          $charset = 'UTF-8'  if $charset =~ /^utf-?16/;
#          $charset = 'cp1252' if $charset eq 'iso-8859-1'; 
#          if (my $encoding = find_encoding($charset)) {
#            return $options->{encoding} ? $encoding : $encoding->name;
#          } 
#        } 
#      } 
#      elsif (m!\G</?[a-zA-Z][^\x09\x0A\x0C\x0D >]*!gc) {
#        1 while &_get_attribute;
#      } 
#      elsif (m{\G<[!/?][^>]*}gc) {
#      } 
#      elsif (m/\G</gc) {
#      } 
#
#      m/\G[^<]+/gc;
#    } 
#  } 
#
#  return undef;                 
#} 
#
#
#*file               = \&html_file;
#*file_and_encoding  = \&html_file_and_encoding;
#*outfile            = \&html_outfile;
#
#
#1;
#
#__END__
#
### IO/Pty.pm ###
#
#package IO::Pty;
#
#use strict;
#use Carp;
#use IO::Tty qw(TIOCSCTTY TCSETCTTY TIOCNOTTY);
#use IO::File;
#require POSIX;
#
#use vars qw(@ISA $VERSION);
#
#$VERSION = '1.12'; 
#
#@ISA = qw(IO::Handle);
#eval { local $^W = 0; undef local $SIG{__DIE__}; require IO::Stty };
#push @ISA, "IO::Stty" if (not $@);  
#
#sub new {
#  my ($class) = $_[0] || "IO::Pty";
#  $class = ref($class) if ref($class);
#  @_ <= 1 or croak 'usage: new $class';
#
#  my ($ptyfd, $ttyfd, $ttyname) = pty_allocate();
#
#  croak "Cannot open a pty" if not defined $ptyfd;
#
#  my $pty = $class->SUPER::new_from_fd($ptyfd, "r+");
#  croak "Cannot create a new $class from fd $ptyfd: $!" if not $pty;
#  $pty->autoflush(1);
#  bless $pty => $class;
#
#  my $slave = IO::Tty->new_from_fd($ttyfd, "r+");
#  croak "Cannot create a new IO::Tty from fd $ttyfd: $!" if not $slave;
#  $slave->autoflush(1);
#
#  ${*$pty}{'io_pty_slave'} = $slave;
#  ${*$pty}{'io_pty_ttyname'} = $ttyname;
#  ${*$slave}{'io_tty_ttyname'} = $ttyname;
#
#  return $pty;
#}
#
#sub ttyname {
#  @_ == 1 or croak 'usage: $pty->ttyname();';
#  my $pty = shift;
#  ${*$pty}{'io_pty_ttyname'};
#}
#
#
#sub close_slave {
#  @_ == 1 or croak 'usage: $pty->close_slave();';
#
#  my $master = shift;
#
#  if (exists ${*$master}{'io_pty_slave'}) {
#    close ${*$master}{'io_pty_slave'};
#    delete ${*$master}{'io_pty_slave'};
#  }
#}
#
#sub slave {
#  @_ == 1 or croak 'usage: $pty->slave();';
#
#  my $master = shift;
#
#  if (exists ${*$master}{'io_pty_slave'}) {
#    return ${*$master}{'io_pty_slave'};
#  }
#
#  my $tty = ${*$master}{'io_pty_ttyname'};
#
#  my $slave = new IO::Tty;
#
#  $slave->open($tty, O_RDWR | O_NOCTTY) ||
#    croak "Cannot open slave $tty: $!";
#
#  return $slave;
#}
#
#sub make_slave_controlling_terminal {
#  @_ == 1 or croak 'usage: $pty->make_slave_controlling_terminal();';
#
#  my $self = shift;
#  local(*DEVTTY);
#
#  if (defined TIOCNOTTY) {
#    if (open (\*DEVTTY, "/dev/tty")) {
#      ioctl( \*DEVTTY, TIOCNOTTY, 0 );
#      close \*DEVTTY;
#    }
#  }
#
#  if (not POSIX::setsid()) {
#    warn "setsid() failed, strange behavior may result: $!\r\n" if $^W;
#  }
#
#  if (open(\*DEVTTY, "/dev/tty")) {
#    warn "Could not disconnect from controlling terminal?!\n" if $^W;
#    close \*DEVTTY;
#  }
#
#  my $ttyname = ${*$self}{'io_pty_ttyname'};
#  my $slv = new IO::Tty;
#  $slv->open($ttyname, O_RDWR)
#    or croak "Cannot open slave $ttyname: $!";
#
#  if (not exists ${*$self}{'io_pty_slave'}) {
#    ${*$self}{'io_pty_slave'} = $slv;
#  } else {
#    $slv->close;
#  }
#
#  if (not open(\*DEVTTY, "/dev/tty")) {
#    if (defined TIOCSCTTY) {
#      if (not defined ioctl( ${*$self}{'io_pty_slave'}, TIOCSCTTY, 0 )) {
#        warn "warning: TIOCSCTTY failed, slave might not be set as controlling terminal: $!" if $^W;
#      }
#    } elsif (defined TCSETCTTY) {
#      if (not defined ioctl( ${*$self}{'io_pty_slave'}, TCSETCTTY, 0 )) {
#        warn "warning: TCSETCTTY failed, slave might not be set as controlling terminal: $!" if $^W;
#      }
#    } else {
#      warn "warning: You have neither TIOCSCTTY nor TCSETCTTY on your system\n" if $^W;
#      return 0;
#    }
#  }
#
#  if (not open(\*DEVTTY, "/dev/tty")) {
#    warn "Error: could not connect pty as controlling terminal!\n";
#    return undef;
#  } else {
#    close \*DEVTTY;
#  }
#  
#  return 1;
#}
#
#*clone_winsize_from = \&IO::Tty::clone_winsize_from;
#*get_winsize = \&IO::Tty::get_winsize;
#*set_winsize = \&IO::Tty::set_winsize;
#*set_raw = \&IO::Tty::set_raw;
#
#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__
#
### IO/Tty.pm ###
#
#package IO::Tty;
#
#use IO::Handle;
#use IO::File;
#use IO::Tty::Constant;
#use Carp;
#
#require POSIX;
#require DynaLoader;
#
#use vars qw(@ISA $VERSION $XS_VERSION $CONFIG $DEBUG);
#
#$VERSION = '1.12';
#$XS_VERSION = "1.12";
#@ISA = qw(IO::Handle);
#
#eval { local $^W = 0; undef local $SIG{__DIE__}; require IO::Stty };
#push @ISA, "IO::Stty" if (not $@);  
#
#BOOT_XS: {
#    require DynaLoader;
#
#    *dl_load_flags = DynaLoader->can('dl_load_flags');
#
#    do {
#	defined(&bootstrap)
#		? \&bootstrap
#		: \&DynaLoader::bootstrap
#    }->(__PACKAGE__);
#}
#
#sub import {
#    IO::Tty::Constant->export_to_level(1, @_);
#}
#
#sub open {
#    my($tty,$dev,$mode) = @_;
#
#    IO::File::open($tty,$dev,$mode) or
#	return undef;
#
#    $tty->autoflush;
#
#    1;
#}
#
#sub clone_winsize_from {
#  my ($self, $fh) = @_;
#  croak "Given filehandle is not a tty in clone_winsize_from, called"
#    if not POSIX::isatty($fh);  
#  return 1 if not POSIX::isatty($self);  
#  my $winsize = " "x1024; 
#  ioctl($fh, &IO::Tty::Constant::TIOCGWINSZ, $winsize)
#    and ioctl($self, &IO::Tty::Constant::TIOCSWINSZ, $winsize)
#      and return 1;
#  warn "clone_winsize_from: error: $!" if $^W;
#  return undef;
#}
#
#my $SIZEOF_WINSIZE = length IO::Tty::pack_winsize(0,0,0,0);
#
#sub get_winsize {
#  my $self = shift;
#  ioctl($self, IO::Tty::Constant::TIOCGWINSZ(), my $winsize)
#    or croak "Cannot TIOCGWINSZ - $!";
#  substr($winsize, $SIZEOF_WINSIZE) = "";
#  return IO::Tty::unpack_winsize($winsize);
#}
#
#sub set_winsize {
#  my $self = shift;
#  my $winsize = IO::Tty::pack_winsize(@_);
#  ioctl($self, IO::Tty::Constant::TIOCSWINSZ(), $winsize)
#    or croak "Cannot TIOCSWINSZ - $!";
#}
#
#sub set_raw($) {
#  require POSIX;
#  my $self = shift;
#  return 1 if not POSIX::isatty($self);
#  my $ttyno = fileno($self);
#  my $termios = new POSIX::Termios;
#  unless ($termios) {
#    warn "set_raw: new POSIX::Termios failed: $!";
#    return undef;
#  }
#  unless ($termios->getattr($ttyno)) {
#    warn "set_raw: getattr($ttyno) failed: $!";
#    return undef;
#  }
#  $termios->setiflag(0);
#  $termios->setoflag(0);
#  $termios->setlflag(0);
#  $termios->setcc(&POSIX::VMIN, 1);
#  $termios->setcc(&POSIX::VTIME, 0);
#  unless ($termios->setattr($ttyno, &POSIX::TCSANOW)) {
#    warn "set_raw: setattr($ttyno) failed: $!";
#    return undef;
#  }
#  return 1;
#}
#
#
#1;
#
#__END__
#
### IPC/Run.pm ###
#package IPC::Run;
#use bytes;
#
#
#use strict;
#use Exporter ();
#use vars qw{$VERSION @ISA @FILTER_IMP @FILTERS @API @EXPORT_OK %EXPORT_TAGS};
#BEGIN {
#	$VERSION = '0.94';
#	@ISA     = qw{ Exporter };
#
#	@FILTER_IMP = qw( input_avail get_more_input );
#	@FILTERS    = qw(
#		new_appender
#		new_chunker
#		new_string_source
#		new_string_sink
#	);
#	@API        = qw(
#		run
#		harness start pump pumpable finish
#		signal kill_kill reap_nb
#		io timer timeout
#		close_terminal
#		binary
#	);
#	@EXPORT_OK = ( @API, @FILTER_IMP, @FILTERS, qw( Win32_MODE ) );
#	%EXPORT_TAGS = (
#		'filter_imp' => \@FILTER_IMP,
#		'all'        => \@EXPORT_OK,
#		'filters'    => \@FILTERS,
#		'api'        => \@API,
#	);
#
#}
#
#use strict;
#use IPC::Run::Debug;
#use Exporter;
#use Fcntl;
#use POSIX ();
#BEGIN { if ($] < 5.008) { require Symbol; } }
#use Carp;
#use File::Spec ();
#use IO::Handle;
#require IPC::Run::IO;
#require IPC::Run::Timer;
#use UNIVERSAL ();
#
#use constant Win32_MODE => $^O =~ /os2|Win32/i;
#
#BEGIN {
#   if ( Win32_MODE ) {
#      eval "use IPC::Run::Win32Helper; 1;"
#         or ( $@ && die ) or die "$!";
#   }
#   else {
#      eval "use File::Basename; 1;" or die $!;
#   }
#}
#
#sub input_avail();
#sub get_more_input();
#
#
#use vars  qw( $_EIO $_EAGAIN );
#use Errno qw(   EIO   EAGAIN );
#BEGIN {
#  local $!;
#  $! = EIO;    $_EIO    = qr/^$!/;
#  $! = EAGAIN; $_EAGAIN = qr/^$!/;
#}
#
#sub _newed()    {0}
#sub _harnessed(){1}
#sub _finished() {2}   
#sub _started()  {3}
#
#my %fds;
#
#
#use vars qw( $cur_self );
#
#sub _debug_fd {
#   return fileno STDERR unless defined $cur_self;
#
#   if ( _debugging && ! defined $cur_self->{DEBUG_FD} ) {
#      my $fd = select STDERR; $| = 1; select $fd;
#      $cur_self->{DEBUG_FD} = POSIX::dup fileno STDERR;
#      _debug( "debugging fd is $cur_self->{DEBUG_FD}\n" )
#         if _debugging_details;
#   }
#
#   return fileno STDERR unless defined $cur_self->{DEBUG_FD};
#
#   return $cur_self->{DEBUG_FD}
#}
#
#sub DESTROY {
#   my IPC::Run $self = shift;
#   POSIX::close $self->{DEBUG_FD} if defined $self->{DEBUG_FD};
#   $self->{DEBUG_FD} = undef;
#}
#
#my %cmd_cache;
#
#sub _search_path {
#   my ( $cmd_name ) = @_;
#   if ( File::Spec->file_name_is_absolute( $cmd_name ) && -x $cmd_name) {
#      _debug "'", $cmd_name, "' is absolute"
#         if _debugging_details;
#      return $cmd_name;
#   }
#
#   my $dirsep =
#      ( Win32_MODE
#         ? '[/\\\\]'
#      : $^O =~ /MacOS/
#         ? ':'
#      : $^O =~ /VMS/
#         ? '[\[\]]'
#      : '/'
#      );
#
#   if ( Win32_MODE
#      && ( $cmd_name =~ /$dirsep/ )
#      && ( $cmd_name !~ m!\.[^\\/\.]+$! )
#    ) {
#
#      _debug "no extension(.exe), checking ENV{PATHEXT}"  if _debugging;
#      for ( split /;/, $ENV{PATHEXT} || ".COM;.BAT;.EXE" ) {
#         my $name = "$cmd_name$_";
#         $cmd_name = $name, last if -f $name && -x _;
#      }
#      _debug "cmd_name is now '$cmd_name'"  if _debugging;
#   }
#
#   if ( $cmd_name =~ /($dirsep)/ ) {
#      _debug "'$cmd_name' contains '$1'"  if _debugging;
#      croak "file not found: $cmd_name"    unless -e $cmd_name;
#      croak "not a file: $cmd_name"        unless -f $cmd_name;
#      croak "permission denied: $cmd_name" unless -x $cmd_name;
#      return $cmd_name;
#   }
#
#   if ( exists $cmd_cache{$cmd_name} ) {
#      _debug "'$cmd_name' found in cache: '$cmd_cache{$cmd_name}'"
#         if _debugging;
#      return $cmd_cache{$cmd_name} if -x $cmd_cache{$cmd_name};
#      _debug "'$cmd_cache{$cmd_name}' no longer executable, searching..."
#         if _debugging;
#      delete $cmd_cache{$cmd_name};
#   }
#
#   my @searched_in;
#
#      my $re = Win32_MODE ? qr/;/ : qr/:/;
#
#LOOP:
#   for ( split( $re, $ENV{PATH} || '', -1 ) ) {
#      $_ = "." unless length $_;
#      push @searched_in, $_;
#
#      my $prospect = File::Spec->catfile( $_, $cmd_name );
#      my @prospects;
#
#      @prospects =
#         ( Win32_MODE && ! ( -f $prospect && -x _ ) )
#            ? map "$prospect$_", split /;/, $ENV{PATHEXT} || ".COM;.BAT;.EXE"
#            : ( $prospect );
#
#      for my $found ( @prospects ) {
#         if ( -f $found && -x _ ) {
#            $cmd_cache{$cmd_name} = $found;
#            last LOOP;
#         }
#      }
#   }
#
#   if ( exists $cmd_cache{$cmd_name} ) {
#      _debug "'", $cmd_name, "' added to cache: '", $cmd_cache{$cmd_name}, "'"
#         if _debugging_details;
#      return $cmd_cache{$cmd_name};
#   }
#
#   croak "Command '$cmd_name' not found in " . join( ", ", @searched_in );
#}
#
#
#sub _empty($) { ! ( defined $_[0] && length $_[0] ) }
#
#sub _close {
#   confess 'undef' unless defined $_[0];
#   my $fd = $_[0] =~ /^\d+$/ ? $_[0] : fileno $_[0];
#   my $r = POSIX::close $fd;
#   $r = $r ? '' : " ERROR $!";
#   delete $fds{$fd};
#   _debug "close( $fd ) = " . ( $r || 0 ) if _debugging_details;
#}
#
#sub _dup {
#   confess 'undef' unless defined $_[0];
#   my $r = POSIX::dup( $_[0] );
#   croak "$!: dup( $_[0] )" unless defined $r;
#   $r = 0 if $r eq '0 but true';
#   _debug "dup( $_[0] ) = $r" if _debugging_details;
#   $fds{$r} = 1;
#   return $r;
#}
#
#
#sub _dup2_rudely {
#   confess 'undef' unless defined $_[0] && defined $_[1];
#   my $r = POSIX::dup2( $_[0], $_[1] );
#   croak "$!: dup2( $_[0], $_[1] )" unless defined $r;
#   $r = 0 if $r eq '0 but true';
#   _debug "dup2( $_[0], $_[1] ) = $r" if _debugging_details;
#   $fds{$r} = 1;
#   return $r;
#}
#
#sub _exec {
#   confess 'undef passed' if grep !defined, @_;
#   _debug 'exec()ing ', join " ", map "'$_'", @_ if _debugging_details;
#
#      exec { $_[0] } @_;
#}
#
#
#sub _sysopen {
#   confess 'undef' unless defined $_[0] && defined $_[1];
#_debug sprintf( "O_RDONLY=0x%02x ", O_RDONLY ),
#sprintf( "O_WRONLY=0x%02x ", O_WRONLY ),
#sprintf( "O_RDWR=0x%02x ", O_RDWR ),
#sprintf( "O_TRUNC=0x%02x ", O_TRUNC),
#sprintf( "O_CREAT=0x%02x ", O_CREAT),
#sprintf( "O_APPEND=0x%02x ", O_APPEND),
#if _debugging_details;
#   my $r = POSIX::open( $_[0], $_[1], 0644 );
#   croak "$!: open( $_[0], ", sprintf( "0x%03x", $_[1] ), " )" unless defined $r;
#   _debug "open( $_[0], ", sprintf( "0x%03x", $_[1] ), " ) = $r"
#      if _debugging_data;
#   $fds{$r} = 1;
#   return $r;
#}
#
#sub _pipe {
#   my ( $r, $w ) = POSIX::pipe;
#   croak "$!: pipe()" unless defined $r;
#   _debug "pipe() = ( $r, $w ) " if _debugging_details;
#   $fds{$r} = $fds{$w} = 1;
#   return ( $r, $w );
#}
#
#sub _pipe_nb {
#   local ( *R, *W );
#   my $f = pipe( R, W );
#   croak "$!: pipe()" unless defined $f;
#   my ( $r, $w ) = ( fileno R, fileno W );
#   _debug "pipe_nb pipe() = ( $r, $w )" if _debugging_details;
#   unless ( Win32_MODE ) {
#      my $fres = fcntl( W, &F_SETFL, O_WRONLY | O_NONBLOCK );
#      croak "$!: fcntl( $w, F_SETFL, O_NONBLOCK )" unless $fres;
#      _debug "fcntl( $w, F_SETFL, O_NONBLOCK )" if _debugging_details;
#   }
#   ( $r, $w ) = ( _dup( $r ), _dup( $w ) );
#   _debug "pipe_nb() = ( $r, $w )" if _debugging_details;
#   return ( $r, $w );
#}
#
#sub _pty {
#   require IO::Pty;
#   my $pty = IO::Pty->new();
#   croak "$!: pty ()" unless $pty;
#   $pty->autoflush();
#   $pty->blocking( 0 ) or croak "$!: pty->blocking ( 0 )";
#   _debug "pty() = ( ", $pty->fileno, ", ", $pty->slave->fileno, " )"
#      if _debugging_details;
#   $fds{$pty->fileno} = $fds{$pty->slave->fileno} = 1;
#   return $pty;
#}
#
#
#sub _read {
#   confess 'undef' unless defined $_[0];
#   my $s  = '';
#   my $r = POSIX::read( $_[0], $s, 10_000 );
#   croak "$!: read( $_[0] )" if not($r) and $! != POSIX::EINTR;
#   $r ||= 0;
#   _debug "read( $_[0] ) = $r chars '$s'" if _debugging_data;
#   return $s;
#}
#
#
#sub _spawn {
#   my IPC::Run $self = shift;
#   my ( $kid ) = @_;
#
#   _debug "opening sync pipe ", $kid->{PID} if _debugging_details;
#   my $sync_reader_fd;
#   ( $sync_reader_fd, $self->{SYNC_WRITER_FD} ) = _pipe;
#   $kid->{PID} = fork();
#   croak "$! during fork" unless defined $kid->{PID};
#
#   unless ( $kid->{PID} ) {
#      $self->_do_kid_and_exit( $kid );
#   }
#   _debug "fork() = ", $kid->{PID} if _debugging_details;
#
#   _close $self->{SYNC_WRITER_FD};
#   my $sync_pulse = _read $sync_reader_fd;
#   _close $sync_reader_fd;
#
#   if ( ! defined $sync_pulse || length $sync_pulse ) {
#      if ( waitpid( $kid->{PID}, 0 ) >= 0 ) {
#	 $kid->{RESULT} = $?;
#      }
#      else {
#	 $kid->{RESULT} = -1;
#      }
#      $sync_pulse =
#         "error reading synchronization pipe for $kid->{NUM}, pid $kid->{PID}"
#	 unless length $sync_pulse;
#      croak $sync_pulse;
#   }
#   return $kid->{PID};
#
#if ( keys %{$self->{PTYS}} && $IO::Pty::VERSION < 0.9 ) {
#_debug "sleeping to give pty a chance to init, will fix when newer IO::Pty arrives.";
#sleep 1;
#}
#}
#
#
#sub _write {
#   confess 'undef' unless defined $_[0] && defined $_[1];
#   my $r = POSIX::write( $_[0], $_[1], length $_[1] );
#   croak "$!: write( $_[0], '$_[1]' )" unless $r;
#   _debug "write( $_[0], '$_[1]' ) = $r" if _debugging_data;
#   return $r;
#}
#
#
#use vars qw( $in_run );  
#
#sub run {
#   local $in_run = 1;  
#   my IPC::Run $self = start( @_ );
#   my $r = eval {
#      $self->{clear_ins} = 0;
#      $self->finish;
#   };
#   if ( $@ ) {
#      my $x = $@;
#      $self->kill_kill;
#      die $x;
#   }
#   return $r;
#}
#
#
#sub signal {
#   my IPC::Run $self = shift;
#
#   local $cur_self = $self;
#
#   $self->_kill_kill_kill_pussycat_kill unless @_;
#
#   Carp::cluck "Ignoring extra parameters passed to kill()" if @_ > 1;
#
#   my ( $signal ) = @_;
#   croak "Undefined signal passed to signal" unless defined $signal;
#   for ( grep $_->{PID} && ! defined $_->{RESULT}, @{$self->{KIDS}} ) {
#      _debug "sending $signal to $_->{PID}"
#         if _debugging;
#      kill $signal, $_->{PID}
#         or _debugging && _debug "$! sending $signal to $_->{PID}";
#   }
#   
#   return;
#}
#
#
#sub kill_kill {
#   my IPC::Run $self = shift;
#
#   my %options = @_;
#   my $grace = $options{grace};
#   $grace = 30 unless defined $grace;
#   ++$grace; 
#
#   my $coup_d_grace = $options{coup_d_grace};
#   $coup_d_grace = "KILL" unless defined $coup_d_grace;
#
#   delete $options{$_} for qw( grace coup_d_grace );
#   Carp::cluck "Ignoring unknown options for kill_kill: ",
#       join " ",keys %options
#       if keys %options;
#
#   $self->signal( "TERM" );
#
#   my $quitting_time = time + $grace;
#   my $delay = 0.01;
#   my $accum_delay;
#
#   my $have_killed_before;
#
#   while () {
#      select undef, undef, undef, $delay;
#      $accum_delay += $delay;
#
#      $self->reap_nb;
#      last unless $self->_running_kids;
#
#      if ( $accum_delay >= $grace*0.8 ) {
#         if ( time >= $quitting_time ) {
#            if ( ! $have_killed_before ) {
#               $self->signal( $coup_d_grace );
#               $have_killed_before = 1;
#               $quitting_time += $grace;
#               $delay = 0.01;
#               $accum_delay = 0;
#               next;
#            }
#            croak "Unable to reap all children, even after KILLing them"
#         }
#      }
#
#      $delay *= 2;
#      $delay = 0.5 if $delay >= 0.5;
#   }
#
#   $self->_cleanup;
#   return $have_killed_before;
#}
#
#
#my $harness_id = 0;
#sub harness {
#   my $options;
#   if ( @_ && ref $_[-1] eq 'HASH' ) {
#      $options = pop;
#      require Data::Dumper;
#      carp "Passing in options as a hash is deprecated:\n", Data::Dumper::Dumper( $options );
#   }
#
#
#   my @args;
#   if ( @_ == 1 && ! ref $_[0] ) {
#      if ( Win32_MODE ) {
#         my $command = $ENV{ComSpec} || 'cmd';
#         @args = ( [ $command, '/c', win32_parse_cmd_line $_[0] ] );
#      }
#      else {
#         @args = ( [ qw( sh -c ), @_ ] );
#      }
#   }
#   elsif ( @_ > 1 && ! grep ref $_, @_ ) {
#      @args = ( [ @_ ] );
#   }
#   else {
#      @args = @_;
#   }
#
#   my @errs;               
#
#   my $succinct;           
#
#   my $cur_kid;            
#
#   my $assumed_fd    = 0;  
#   my $handle_num    = 0;  
#
#   my IPC::Run $self = bless {}, __PACKAGE__;
#
#   local $cur_self = $self;
#
#   $self->{ID}    = ++$harness_id;
#   $self->{IOS}   = [];
#   $self->{KIDS}  = [];
#   $self->{PIPES} = [];
#   $self->{PTYS}  = {};
#   $self->{STATE} = _newed;
#
#   if ( $options ) {
#      $self->{$_} = $options->{$_}
#         for keys %$options;
#   }
#
#   _debug "****** harnessing *****" if _debugging;
#
#   my $first_parse;
#   local $_;
#   my $arg_count = @args;
#   while ( @args ) { for ( shift @args ) {
#      eval {
#         $first_parse = 1;
#         _debug(
#            "parsing ",
#            defined $_
#               ? ref $_ eq 'ARRAY'
#                  ? ( '[ ', join( ', ', map "'$_'", @$_ ), ' ]' )
#                  : ( ref $_
#                     || ( length $_ < 50
#                           ? "'$_'"
#                           : join( '', "'", substr( $_, 0, 10 ), "...'" )
#                        )
#                  )
#               : '<undef>'
#         ) if _debugging;
#
#      REPARSE:
#         if ( ref eq 'ARRAY' || ( ! $cur_kid && ref eq 'CODE' ) ) {
#            croak "Process control symbol ('|', '&') missing" if $cur_kid;
#            croak "Can't spawn a subroutine on Win32"
#	       if Win32_MODE && ref eq "CODE";
#            $cur_kid = {
#               TYPE   => 'cmd',
#               VAL    => $_,
#               NUM    => @{$self->{KIDS}} + 1,
#               OPS    => [],
#               PID    => '',
#               RESULT => undef,
#            };
#            push @{$self->{KIDS}}, $cur_kid;
#            $succinct = 1;
#         }
#
#         elsif ( UNIVERSAL::isa( $_, 'IPC::Run::IO' ) ) {
#            push @{$self->{IOS}}, $_;
#            $cur_kid = undef;
#            $succinct = 1;
#         }
#         
#         elsif ( UNIVERSAL::isa( $_, 'IPC::Run::Timer' ) ) {
#            push @{$self->{TIMERS}}, $_;
#            $cur_kid = undef;
#            $succinct = 1;
#         }
#         
#         elsif ( /^(\d*)>&(\d+)$/ ) {
#            croak "No command before '$_'" unless $cur_kid;
#            push @{$cur_kid->{OPS}}, {
#               TYPE => 'dup',
#               KFD1 => $2,
#               KFD2 => length $1 ? $1 : 1,
#            };
#            _debug "redirect operators now required" if _debugging_details;
#            $succinct = ! $first_parse;
#         }
#
#         elsif ( /^(\d*)<&(\d+)$/ ) {
#            croak "No command before '$_'" unless $cur_kid;
#            push @{$cur_kid->{OPS}}, {
#               TYPE => 'dup',
#               KFD1 => $2,
#               KFD2 => length $1 ? $1 : 0,
#            };
#            $succinct = ! $first_parse;
#         }
#
#         elsif ( /^(\d*)<&-$/ ) {
#            croak "No command before '$_'" unless $cur_kid;
#            push @{$cur_kid->{OPS}}, {
#               TYPE => 'close',
#               KFD  => length $1 ? $1 : 0,
#            };
#            $succinct = ! $first_parse;
#         }
#
#         elsif (
#               /^(\d*) (<pipe)()            ()  ()  $/x
#            || /^(\d*) (<pty) ((?:\s+\S+)?) (<) ()  $/x
#            || /^(\d*) (<)    ()            ()  (.*)$/x
#         ) {
#            croak "No command before '$_'" unless $cur_kid;
#
#            $succinct = ! $first_parse;
#
#            my $type = $2 . $4;
#
#            my $kfd = length $1 ? $1 : 0;
#
#            my $pty_id;
#            if ( $type eq '<pty<' ) {
#               $pty_id = length $3 ? $3 : '0';
#               require IO::Pty;
#               $self->{PTYS}->{$pty_id} = undef;
#            }
#
#            my $source = $5;
#
#            my @filters;
#            my $binmode;
#
#            unless ( length $source ) {
#               if ( ! $succinct ) {
#                  while ( @args > 1
#                      && (
#                         ( ref $args[1] && ! UNIVERSAL::isa $args[1], "IPC::Run::Timer" )
#                         || UNIVERSAL::isa $args[0], "IPC::Run::binmode_pseudo_filter"
#                      )
#                  ) {
#                     if ( UNIVERSAL::isa $args[0], "IPC::Run::binmode_pseudo_filter" ) {
#                        $binmode = shift( @args )->();
#                     }
#                     else {
#                        push @filters, shift @args
#                     }
#                  }
#               }
#               $source = shift @args;
#               croak "'$_' missing a source" if _empty $source;
#
#               _debug(
#                  'Kid ', $cur_kid->{NUM}, "'s input fd ", $kfd,
#                  ' has ', scalar( @filters ), ' filters.'
#               ) if _debugging_details && @filters;
#            };
#
#            my IPC::Run::IO $pipe = IPC::Run::IO->_new_internal(
#               $type, $kfd, $pty_id, $source, $binmode, @filters
#            );
#
#            if ( ( ref $source eq 'GLOB' || UNIVERSAL::isa $source, 'IO::Handle' )
#               && $type !~ /^<p(ty<|ipe)$/
#            ) {
#	       _debug "setting DONT_CLOSE" if _debugging_details;
#               $pipe->{DONT_CLOSE} = 1; 
#	       _dont_inherit( $source ) if Win32_MODE;
#            }
#
#            push @{$cur_kid->{OPS}}, $pipe;
#      }
#
#         elsif ( /^()   (>>?)  (&)     ()      (.*)$/x
#            ||   /^()   (&)    (>pipe) ()      ()  $/x 
#            ||   /^()   (>pipe)(&)     ()      ()  $/x 
#            ||   /^(\d*)()     (>pipe) ()      ()  $/x
#            ||   /^()   (&)    (>pty)  ( \w*)> ()  $/x 
#            ||   /^(\d*)()     (>pty)  ( \w*)> ()  $/x
#            ||   /^()   (&)    (>>?)   ()      (.*)$/x 
#            ||   /^(\d*)()     (>>?)   ()      (.*)$/x
#         ) {
#            croak "No command before '$_'" unless $cur_kid;
#
#            $succinct = ! $first_parse;
#
#            my $type = (
#               $2 eq '>pipe' || $3 eq '>pipe'
#                  ? '>pipe'
#                  : $2 eq '>pty' || $3 eq '>pty'
#                     ? '>pty>'
#                     : '>'
#            );
#            my $kfd = length $1 ? $1 : 1;
#            my $trunc = ! ( $2 eq '>>' || $3 eq '>>' );
#            my $pty_id = (
#               $2 eq '>pty' || $3 eq '>pty'
#                  ? length $4 ? $4 : 0
#                  : undef
#            );
#
#            my $stderr_too =
#                  $2 eq '&'
#               || $3 eq '&'
#               || ( ! length $1 && substr( $type, 0, 4 ) eq '>pty' );
#
#            my $dest = $5;
#            my @filters;
#            my $binmode = 0;
#            unless ( length $dest ) {
#               if ( ! $succinct ) {
#                  while ( @args > 1
#                     && ( 
#                        ( ref $args[1] && !  UNIVERSAL::isa $args[1], "IPC::Run::Timer" )
#                        || UNIVERSAL::isa $args[0], "IPC::Run::binmode_pseudo_filter"
#                     )
#                  ) {
#                     if ( UNIVERSAL::isa $args[0], "IPC::Run::binmode_pseudo_filter" ) {
#                        $binmode = shift( @args )->();
#                     }
#                     else {
#                        unshift @filters, shift @args;
#                     }
#                  }
#               }
#
#               $dest = shift @args;
#
#               _debug(
#                  'Kid ', $cur_kid->{NUM}, "'s output fd ", $kfd,
#                  ' has ', scalar( @filters ), ' filters.'
#               ) if _debugging_details && @filters;
#
#               if ( $type eq '>pty>' ) {
#                  require IO::Pty;
#                  $self->{PTYS}->{$pty_id} = undef;
#               }
#            }
#
#            croak "'$_' missing a destination" if _empty $dest;
#            my $pipe = IPC::Run::IO->_new_internal(
#               $type, $kfd, $pty_id, $dest, $binmode, @filters
#            );
#            $pipe->{TRUNC} = $trunc;
#
#            if (  ( UNIVERSAL::isa( $dest, 'GLOB' ) || UNIVERSAL::isa( $dest, 'IO::Handle' ) )
#               && $type !~ /^>(pty>|pipe)$/
#            ) {
#	       _debug "setting DONT_CLOSE" if _debugging_details;
#               $pipe->{DONT_CLOSE} = 1; 
#            }
#            push @{$cur_kid->{OPS}}, $pipe;
#            push @{$cur_kid->{OPS}}, {
#               TYPE => 'dup',
#               KFD1 => 1,
#               KFD2 => 2,
#            } if $stderr_too;
#         }
#
#         elsif ( $_ eq "|" ) {
#            croak "No command before '$_'" unless $cur_kid;
#            unshift @{$cur_kid->{OPS}}, {
#               TYPE => '|',
#               KFD  => 1,
#            };
#            $succinct   = 1;
#            $assumed_fd = 1;
#            $cur_kid    = undef;
#         }
#
#         elsif ( $_ eq "&" ) {
#            croak "No command before '$_'" unless $cur_kid;
#            unshift @{$cur_kid->{OPS}}, {
#               TYPE => 'close',
#               KFD  => 0,
#            };
#            $succinct   = 1;
#            $assumed_fd = 0;
#            $cur_kid    = undef;
#         }
#
#         elsif ( $_ eq 'init' ) {
#            croak "No command before '$_'" unless $cur_kid;
#            push @{$cur_kid->{OPS}}, {
#               TYPE => 'init',
#               SUB  => shift @args,
#            };
#         }
#
#         elsif ( ! ref $_ ) {
#            $self->{$_} = shift @args;
#         }
#
#         elsif ( $_ eq 'init' ) {
#            croak "No command before '$_'" unless $cur_kid;
#            push @{$cur_kid->{OPS}}, {
#               TYPE => 'init',
#               SUB  => shift @args,
#            };
#         }
#
#         elsif ( $succinct && $first_parse ) {
#            unshift @args, $_;
#            if ( ! $assumed_fd ) {
#               $_ = "$assumed_fd<",
#            }
#            else {
#               $_ = "$assumed_fd>",
#            }
#            _debug "assuming '", $_, "'" if _debugging_details;
#            ++$assumed_fd;
#            $first_parse = 0;
#            goto REPARSE;
#         }
#
#         else {
#            croak join( 
#               '',
#               'Unexpected ',
#               ( ref() ? $_ : 'scalar' ),
#               ' in harness() parameter ',
#               $arg_count - @args
#            );
#         }
#      };
#      if ( $@ ) {
#         push @errs, $@;
#         _debug 'caught ', $@ if _debugging;
#      }
#   } }
#
#   die join( '', @errs ) if @errs;
#
#
#   $self->{STATE} = _harnessed;
#   return $self;
#}
#
#
#sub _open_pipes {
#   my IPC::Run $self = shift;
#
#   my @errs;
#
#   my @close_on_fail;
#
#   my $pipe_read_fd;
#
#   my @output_fds_accum;
#
#   for ( sort keys %{$self->{PTYS}} ) {
#      _debug "opening pty '", $_, "'" if _debugging_details;
#      my $pty = _pty;
#      $self->{PTYS}->{$_} = $pty;
#   }
#
#   for ( @{$self->{IOS}} ) {
#      eval { $_->init; };
#      if ( $@ ) {
#         push @errs, $@;
#         _debug 'caught ', $@ if _debugging;
#      }
#      else {
#         push @close_on_fail, $_;
#      }
#   }
#
#   for my $kid ( @{$self->{KIDS}} ) {
#      unless ( ref $kid->{VAL} eq 'CODE' ) {
#         $kid->{PATH} = _search_path $kid->{VAL}->[0];
#      }
#      if ( defined $pipe_read_fd ) {
#	 _debug "placing write end of pipe on kid $kid->{NUM}'s stdin"
#	    if _debugging_details;
#         unshift @{$kid->{OPS}}, {
#            TYPE => 'PIPE',  
#            KFD  => 0,
#            TFD  => $pipe_read_fd,
#         };
#         $pipe_read_fd = undef;
#      }
#      @output_fds_accum = ();
#      for my $op ( @{$kid->{OPS}} ) {
#         my $ok = eval {
#            if ( $op->{TYPE} eq '<' ) {
#               my $source = $op->{SOURCE};
#	       if ( ! ref $source ) {
#		  _debug(
#		     "kid ", $kid->{NUM}, " to read ", $op->{KFD},
#		     " from '" .  $source, "' (read only)"
#		  ) if _debugging_details;
#		  croak "simulated open failure"
#		     if $self->{_simulate_open_failure};
#		  $op->{TFD} = _sysopen( $source, O_RDONLY );
#		  push @close_on_fail, $op->{TFD};
#	       }
#	       elsif ( UNIVERSAL::isa( $source, 'GLOB' )
#		  ||   UNIVERSAL::isa( $source, 'IO::Handle' )
#	       ) {
#		  croak
#		     "Unopened filehandle in input redirect for $op->{KFD}"
#		     unless defined fileno $source;
#		  $op->{TFD} = fileno $source;
#		  _debug(
#		     "kid ", $kid->{NUM}, " to read ", $op->{KFD},
#		     " from fd ", $op->{TFD}
#		  ) if _debugging_details;
#	       }
#	       elsif ( UNIVERSAL::isa( $source, 'SCALAR' ) ) {
#		  _debug(
#		     "kid ", $kid->{NUM}, " to read ", $op->{KFD},
#		     " from SCALAR"
#		  ) if _debugging_details;
#
#		  $op->open_pipe( $self->_debug_fd );
#		  push @close_on_fail, $op->{KFD}, $op->{FD};
#
#		  my $s = '';
#		  $op->{KIN_REF} = \$s;
#	       }
#	       elsif ( UNIVERSAL::isa( $source, 'CODE' ) ) {
#		  _debug(
#		     'kid ', $kid->{NUM}, ' to read ', $op->{KFD}, ' from CODE'
#		  ) if _debugging_details;
#		  
#		  $op->open_pipe( $self->_debug_fd );
#		  push @close_on_fail, $op->{KFD}, $op->{FD};
#		  
#		  my $s = '';
#		  $op->{KIN_REF} = \$s;
#	       }
#	       else {
#		  croak(
#		     "'"
#		     . ref( $source )
#		     . "' not allowed as a source for input redirection"
#		  );
#	       }
#               $op->_init_filters;
#            }
#            elsif ( $op->{TYPE} eq '<pipe' ) {
#               _debug(
#                  'kid to read ', $op->{KFD},
#                  ' from a pipe IPC::Run opens and returns',
#               ) if _debugging_details;
#
#               my ( $r, $w ) = $op->open_pipe( $self->_debug_fd, $op->{SOURCE} );
#	       _debug "caller will write to ", fileno $op->{SOURCE}
#	          if _debugging_details;
#
#               $op->{TFD}    = $r;
#	       $op->{FD}     = undef; 
#               $op->_init_filters;
#            }
#            elsif ( $op->{TYPE} eq '<pty<' ) {
#               _debug(
#                  'kid to read ', $op->{KFD}, " from pty '", $op->{PTY_ID}, "'",
#               ) if _debugging_details;
#               
#               for my $source ( $op->{SOURCE} ) {
#                  if ( UNIVERSAL::isa( $source, 'SCALAR' ) ) {
#                     _debug(
#                        "kid ", $kid->{NUM}, " to read ", $op->{KFD},
#                        " from SCALAR via pty '", $op->{PTY_ID}, "'"
#                     ) if _debugging_details;
#
#                     my $s = '';
#                     $op->{KIN_REF} = \$s;
#                  }
#                  elsif ( UNIVERSAL::isa( $source, 'CODE' ) ) {
#                     _debug(
#                        "kid ", $kid->{NUM}, " to read ", $op->{KFD},
#                        " from CODE via pty '", $op->{PTY_ID}, "'"
#                     ) if _debugging_details;
#                     my $s = '';
#                     $op->{KIN_REF} = \$s;
#                  }
#                  else {
#                     croak(
#                        "'"
#                        . ref( $source )
#                        . "' not allowed as a source for '<pty<' redirection"
#                     );
#                  }
#               }
#               $op->{FD} = $self->{PTYS}->{$op->{PTY_ID}}->fileno;
#               $op->{TFD} = undef; 
#               $op->_init_filters;
#            }
#            elsif ( $op->{TYPE} eq '>' ) {
#               my $dest = $op->{DEST};
#               if ( ! ref $dest ) {
#                  _debug(
#                     "kid ", $kid->{NUM}, " to write ", $op->{KFD},
#                     " to '", $dest, "' (write only, create, ",
#                     ( $op->{TRUNC} ? 'truncate' : 'append' ),
#                     ")"
#                  ) if _debugging_details;
#                  croak "simulated open failure"
#                     if $self->{_simulate_open_failure};
#                  $op->{TFD} = _sysopen(
#                     $dest,
#                     ( O_WRONLY
#                     | O_CREAT 
#                     | ( $op->{TRUNC} ? O_TRUNC : O_APPEND )
#                     )
#                  );
#		  if ( Win32_MODE ) {
#		     POSIX::lseek( $op->{TFD}, 0, POSIX::SEEK_END() );
#		  }
#                  push @close_on_fail, $op->{TFD};
#               }
#               elsif ( UNIVERSAL::isa( $dest, 'GLOB' ) ) {
#                  croak(
#                   "Unopened filehandle in output redirect, command $kid->{NUM}"
#                  ) unless defined fileno $dest;
#                  my $old_fh = select( $dest ); $| = 1; select( $old_fh );
#                  $op->{TFD} = fileno $dest;
#                  _debug(
#                     'kid to write ', $op->{KFD}, ' to handle ', $op->{TFD}
#                  ) if _debugging_details;
#               }
#               elsif ( UNIVERSAL::isa( $dest, 'SCALAR' ) ) {
#                  _debug(
#                     "kid ", $kid->{NUM}, " to write $op->{KFD} to SCALAR"
#                  ) if _debugging_details;
#
#		  $op->open_pipe( $self->_debug_fd );
#                  push @close_on_fail, $op->{FD}, $op->{TFD};
#                  $$dest = '' if $op->{TRUNC};
#               }
#               elsif ( UNIVERSAL::isa( $dest, 'CODE' ) ) {
#                  _debug(
#                     "kid $kid->{NUM} to write $op->{KFD} to CODE"
#                  ) if _debugging_details;
#
#		  $op->open_pipe( $self->_debug_fd );
#                  push @close_on_fail, $op->{FD}, $op->{TFD};
#               }
#               else {
#                  croak(
#                     "'"
#                     . ref( $dest )
#                     . "' not allowed as a sink for output redirection"
#                  );
#               }
#               $output_fds_accum[$op->{KFD}] = $op;
#               $op->_init_filters;
#            }
#
#            elsif ( $op->{TYPE} eq '>pipe' ) {
#               _debug(
#                  "kid ", $kid->{NUM}, " to write ", $op->{KFD},
#		  ' to a pipe IPC::Run opens and returns'
#               ) if _debugging_details;
#
#               my ( $r, $w ) = $op->open_pipe( $self->_debug_fd, $op->{DEST} );
#	       _debug "caller will read from ", fileno $op->{DEST}
#	          if _debugging_details;
#
#               $op->{TFD} = $w;
#	       $op->{FD}  = undef; 
#               $op->_init_filters;
#
#               $output_fds_accum[$op->{KFD}] = $op;
#            }
#            elsif ( $op->{TYPE} eq '>pty>' ) {
#               my $dest = $op->{DEST};
#               if ( UNIVERSAL::isa( $dest, 'SCALAR' ) ) {
#                  _debug(
#                     "kid ", $kid->{NUM}, " to write ", $op->{KFD},
#                     " to SCALAR via pty '", $op->{PTY_ID}, "'"
#               ) if _debugging_details;
#
#                  $$dest = '' if $op->{TRUNC};
#               }
#               elsif ( UNIVERSAL::isa( $dest, 'CODE' ) ) {
#                  _debug(
#                     "kid ", $kid->{NUM}, " to write ", $op->{KFD},
#                     " to CODE via pty '", $op->{PTY_ID}, "'"
#                  ) if _debugging_details;
#               }
#               else {
#                  croak(
#                     "'"
#                     . ref( $dest )
#                     . "' not allowed as a sink for output redirection"
#                  );
#               }
#
#               $op->{FD} = $self->{PTYS}->{$op->{PTY_ID}}->fileno;
#               $op->{TFD} = undef; 
#               $output_fds_accum[$op->{KFD}] = $op;
#               $op->_init_filters;
#            }
#            elsif ( $op->{TYPE} eq '|' ) {
#               _debug(
#                  "pipelining $kid->{NUM} and "
#                  . ( $kid->{NUM} + 1 )
#               ) if _debugging_details;
#               ( $pipe_read_fd, $op->{TFD} ) = _pipe;
#	       if ( Win32_MODE ) {
#		  _dont_inherit( $pipe_read_fd );
#		  _dont_inherit( $op->{TFD} );
#	       }
#               @output_fds_accum = ();
#            }
#            elsif ( $op->{TYPE} eq '&' ) {
#               @output_fds_accum = ();
#            } 
#	    1;
#	 }; 
#	 unless ( $ok ) {
#	    push @errs, $@;
#	    _debug 'caught ', $@ if _debugging;
#	 }
#      } 
#   }
#
#   if ( @errs ) {
#      for ( @close_on_fail ) {
#         _close( $_ );
#         $_ = undef;
#      }
#      for ( keys %{$self->{PTYS}} ) {
#         next unless $self->{PTYS}->{$_};
#         close $self->{PTYS}->{$_};
#         $self->{PTYS}->{$_} = undef;
#      }
#      die join( '', @errs )
#   }
#
#   for ( my $num = 0; $num < $#{$self->{KIDS}}; ++$num ) {
#      for ( reverse @output_fds_accum ) {
#         next unless defined $_;
#         _debug(
#            'kid ', $self->{KIDS}->[$num]->{NUM}, ' also to write ', $_->{KFD},
#            ' to ', ref $_->{DEST}
#         ) if _debugging_details;
#         unshift @{$self->{KIDS}->[$num]->{OPS}}, $_;
#      }
#   }
#
#   @{$self->{PIPES}} = ();
#   $self->{RIN} = '';
#   $self->{WIN} = '';
#   $self->{EIN} = '';
#   $self->{PIN} = '';
#   for my $kid ( @{$self->{KIDS}} ) {
#      for ( @{$kid->{OPS}} ) {
#         if ( defined $_->{FD} ) {
#            _debug(
#               'kid ', $kid->{NUM}, '[', $kid->{PID}, "]'s ", $_->{KFD},
#               ' is my ', $_->{FD}
#            ) if _debugging_details;
#            vec( $self->{ $_->{TYPE} =~ /^</ ? 'WIN' : 'RIN' }, $_->{FD}, 1 ) = 1;
#            push @{$self->{PIPES}}, $_;
#         }
#      }
#   }
#
#   for my $io ( @{$self->{IOS}} ) {
#      my $fd = $io->fileno;
#      vec( $self->{RIN}, $fd, 1 ) = 1 if $io->mode =~ /r/;
#      vec( $self->{WIN}, $fd, 1 ) = 1 if $io->mode =~ /w/;
#      push @{$self->{PIPES}}, $io;
#   }
#
#   for my $pipe ( @{$self->{PIPES}} ) {
#      $pipe->{SOURCE_EMPTY} = 0;
#      $pipe->{PAUSED} = 0;
#      if ( $pipe->{TYPE} =~ /^>/ ) {
#         my $pipe_reader = sub {
#            my ( undef, $out_ref ) = @_;
#
#            return undef unless defined $pipe->{FD};
#            return 0 unless vec( $self->{ROUT}, $pipe->{FD}, 1 );
#
#            vec( $self->{ROUT}, $pipe->{FD}, 1 ) = 0;
#
#            _debug_desc_fd( 'reading from', $pipe ) if _debugging_details;
#            my $in = eval { _read( $pipe->{FD} ) };
#            if ( $@ ) {
#               $in = '';
#               die $@ unless
#	          $@ =~ $_EIO ||
#		  ($@ =~ /input or output/ && $^O =~ /aix/) 
#		  || ( Win32_MODE && $@ =~ /Bad file descriptor/ );
#            }
#
#            unless ( length $in ) {
#               $self->_clobber( $pipe );
#               return undef;
#            }
#
#            my $pos = pos $$out_ref;
#            $$out_ref .= $in;
#            pos( $$out_ref ) = $pos;
#            return 1;
#         };
#         push @{$pipe->{FILTERS}}, $pipe_reader;
#         push @{$self->{TEMP_FILTERS}}, $pipe_reader;
#      }
#      else {
#         my $pipe_writer = sub {
#            my ( $in_ref, $out_ref ) = @_;
#            return undef unless defined $pipe->{FD};
#            return 0
#               unless vec( $self->{WOUT}, $pipe->{FD}, 1 )
#                  || $pipe->{PAUSED};
#
#            vec( $self->{WOUT}, $pipe->{FD}, 1 ) = 0;
#
#            if ( ! length $$in_ref ) {
#               if ( ! defined get_more_input ) {
#                  $self->_clobber( $pipe );
#                  return undef;
#               }
#            }
#
#            unless ( length $$in_ref ) {
#               unless ( $pipe->{PAUSED} ) {
#                  _debug_desc_fd( 'pausing', $pipe ) if _debugging_details;
#                  vec( $self->{WIN}, $pipe->{FD}, 1 ) = 0;
#                  vec( $self->{PIN}, $pipe->{FD}, 1 ) = 1;
#                  $pipe->{PAUSED} = 1;
#               }
#               return 0;
#            }
#            _debug_desc_fd( 'writing to', $pipe ) if _debugging_details;
#
#            my $c = _write( $pipe->{FD}, $$in_ref );
#            substr( $$in_ref, 0, $c, '' );
#            return 1;
#         };
#         unshift @{$pipe->{FILTERS}}, $pipe_writer;
#         push    @{$self->{TEMP_FILTERS}}, $pipe_writer;
#      }
#   }
#}
#
#
#sub _dup2_gently {
#   my IPC::Run $self = shift;
#   my ( $files, $fd1, $fd2 ) = @_;
#   for ( @$files ) {
#      next unless defined $_->{TFD};
#      $_->{TFD} = _dup( $_->{TFD} ) if $_->{TFD} == $fd2;
#   }
#   $self->{DEBUG_FD} = _dup $self->{DEBUG_FD}
#      if defined $self->{DEBUG_FD} && $self->{DEBUG_FD} == $fd2;
#
#   _dup2_rudely( $fd1, $fd2 );
#}
#
#
#
#sub close_terminal {
#
#   POSIX::setsid() || croak "POSIX::setsid() failed";
#   _debug "closing stdin, out, err"
#      if _debugging_details;
#   close STDIN;
#   close STDERR;
#   close STDOUT;
#}
#
#
#sub _do_kid_and_exit {
#   my IPC::Run $self = shift;
#   my ( $kid ) = @_;
#
#   my ( $s1, $s2 );
#   if ($] < 5.008) {
#     $s1 = Symbol::gensym();
#     $s2 = Symbol::gensym();
#   }
#
#   eval {
#      local $cur_self = $self;
#
#      if ( _debugging ) {
#         _set_child_debug_name( ref $kid->{VAL} eq "CODE"
#         	 ? "CODE"
#         	 : basename( $kid->{VAL}->[0] )
#         );
#      }
#
#      my @needed = $self->{noinherit} ? () : ( 1, 1, 1 );
#      $needed[ $self->{SYNC_WRITER_FD} ] = 1;
#      $needed[ $self->{DEBUG_FD} ] = 1 if defined $self->{DEBUG_FD};
#
#      for ( @{$kid->{OPS}} ) {
#	 $needed[ $_->{TFD} ] = 1 if defined $_->{TFD};
#      }
#
#      my @closed;
#      if ( %{$self->{PTYS}} ) {
#	 for ( keys %{$self->{PTYS}} ) {
#	    _debug "Cleaning up parent's ptty '$_'" if _debugging_details;
#	    my $slave = $self->{PTYS}->{$_}->slave;
#	    $closed[ $self->{PTYS}->{$_}->fileno ] = 1;
#	    close $self->{PTYS}->{$_};
#	    $self->{PTYS}->{$_} = $slave;
#	 }
#
#	 close_terminal;
#	 $closed[ $_ ] = 1 for ( 0..2 );
#      }
#
#      for my $sibling ( @{$self->{KIDS}} ) {
#	 for ( @{$sibling->{OPS}} ) {
#	    if ( $_->{TYPE} =~ /^.pty.$/ ) {
#	       $_->{TFD} = $self->{PTYS}->{$_->{PTY_ID}}->fileno;
#	       $needed[$_->{TFD}] = 1;
#	    }
#
#	 }
#      }
#
#      _debug "open fds: ", join " ", keys %fds if _debugging_details;
#      for (keys %fds) {
#         if ( ! $closed[$_] && ! $needed[$_] ) {
#            _close( $_ );
#            $closed[$_] = 1;
#         }
#      }
#
#      my @lazy_close;
#      for ( @{$kid->{OPS}} ) {
#	 if ( defined $_->{TFD} ) {
#	    unless ( $_->{TFD} == $_->{KFD} ) {
#	       $self->_dup2_gently( $kid->{OPS}, $_->{TFD}, $_->{KFD} );
#	       push @lazy_close, $_->{TFD};
#	    }
#	 }
#	 elsif ( $_->{TYPE} eq 'dup' ) {
#	    $self->_dup2_gently( $kid->{OPS}, $_->{KFD1}, $_->{KFD2} )
#	       unless $_->{KFD1} == $_->{KFD2};
#	 }
#	 elsif ( $_->{TYPE} eq 'close' ) {
#	    for ( $_->{KFD} ) {
#	       if ( ! $closed[$_] ) {
#		  _close( $_ );
#		  $closed[$_] = 1;
#		  $_ = undef;
#	       }
#	    }
#	 }
#	 elsif ( $_->{TYPE} eq 'init' ) {
#	    $_->{SUB}->();
#	 }
#      }
#
#      for ( @lazy_close ) {
#	 unless ( $closed[$_] ) {
#	    _close( $_ );
#	    $closed[$_] = 1;
#	 }
#      }
#
#      if ( ref $kid->{VAL} ne 'CODE' ) {
#	 open $s1, ">&=$self->{SYNC_WRITER_FD}"
#	    or croak "$! setting filehandle to fd SYNC_WRITER_FD";
#	 fcntl $s1, F_SETFD, 1;
#
#	 if ( defined $self->{DEBUG_FD} ) {
#	    open $s2, ">&=$self->{DEBUG_FD}"
#	       or croak "$! setting filehandle to fd DEBUG_FD";
#	    fcntl $s2, F_SETFD, 1;
#	 }
#
#	 if ( _debugging ) {
#	    my @cmd = ( $kid->{PATH}, @{$kid->{VAL}}[1..$#{$kid->{VAL}}] );
#	    _debug 'execing ', join " ", map { /[\s\"]/ ? "'$_'" : $_ } @cmd;
#	 }
#
#	 die "exec failed: simulating exec() failure"
#	    if $self->{_simulate_exec_failure};
#
#	 _exec $kid->{PATH}, @{$kid->{VAL}}[1..$#{$kid->{VAL}}];
#
#	 croak "exec failed: $!";
#      }
#   };
#   if ( $@ ) {
#      _write $self->{SYNC_WRITER_FD}, $@;
#      POSIX::exit 1;
#   }
#
#   _close $self->{SYNC_WRITER_FD};
#   _debug 'calling fork()ed CODE ref' if _debugging;
#   POSIX::close $self->{DEBUG_FD}      if defined $self->{DEBUG_FD};
#   $kid->{VAL}->();
#
#   $kid->{VAL} = undef;
#
#   POSIX::exit 0;
#}
#
#
#sub start {
#   my $options;
#   if ( @_ && ref $_[-1] eq 'HASH' ) {
#      $options = pop;
#      require Data::Dumper;
#      carp "Passing in options as a hash is deprecated:\n", Data::Dumper::Dumper( $options );
#   }
#
#   my IPC::Run $self;
#   if ( @_ == 1 && UNIVERSAL::isa( $_[0], __PACKAGE__ ) ) {
#      $self = shift;
#      $self->{$_} = $options->{$_} for keys %$options;
#   }
#   else {
#      $self = harness( @_, $options ? $options : () );
#   }
#
#   local $cur_self = $self;
#
#   $self->kill_kill if $self->{STATE} == _started;
#
#   _debug "** starting" if _debugging;
#
#   $_->{RESULT} = undef for @{$self->{KIDS}};
#
#   $self->{clear_ins} = 1;
#
#   IPC::Run::Win32Helper::optimize $self
#       if Win32_MODE && $in_run;
#
#   my @errs;
#
#   for ( @{$self->{TIMERS}} ) {
#      eval { $_->start };
#      if ( $@ ) {
#         push @errs, $@;
#         _debug 'caught ', $@ if _debugging;
#      }
#   }
#
#   eval { $self->_open_pipes };
#   if ( $@ ) {
#      push @errs, $@;
#      _debug 'caught ', $@ if _debugging;
#   }
#
#   if ( ! @errs ) {
#      { my $ofh = select STDOUT; local $| = 1; select $ofh; }
#      { my $ofh = select STDERR; local $| = 1; select $ofh; }
#      for my $kid ( @{$self->{KIDS}} ) {
#         $kid->{RESULT} = undef;
#         _debug "child: ",
#            ref( $kid->{VAL} ) eq "CODE"
#            ? "CODE ref"
#            : (
#               "`",
#               join( " ", map /[^\w.-]/ ? "'$_'" : $_, @{$kid->{VAL}} ),
#               "`"
#            ) if _debugging_details;
#         eval {
#            croak "simulated failure of fork"
#               if $self->{_simulate_fork_failure};
#            unless ( Win32_MODE ) {
#	       $self->_spawn( $kid );
#            }
#            else {
#               _debug( 
#                  'spawning ',
#                  join(
#                     ' ',
#                     map(
#                        "'$_'",
#                        ( $kid->{PATH}, @{$kid->{VAL}}[1..$#{$kid->{VAL}}] )
#                     )
#                  )
#               ) if _debugging;
#	       _dont_inherit( $self->{DEBUG_FD} );
#               ( $kid->{PID}, $kid->{PROCESS} ) =
#		  IPC::Run::Win32Helper::win32_spawn( 
#		     [ $kid->{PATH}, @{$kid->{VAL}}[1..$#{$kid->{VAL}}] ],
#		     $kid->{OPS},
#		  );
#               _debug "spawn() = ", $kid->{PID} if _debugging;
#            }
#         };
#         if ( $@ ) {
#            push @errs, $@;
#            _debug 'caught ', $@ if _debugging;
#         }
#      }
#   }
#
#   for my $pty ( values %{$self->{PTYS}} ) {
#      close $pty->slave;
#   }
#
#   my @closed;
#   for my $kid ( @{$self->{KIDS}} ) {
#      for ( @{$kid->{OPS}} ) {
#         my $close_it = eval {
#            defined $_->{TFD}
#               && ! $_->{DONT_CLOSE}
#               && ! $closed[$_->{TFD}]
#               && ( ! Win32_MODE || ! $_->{RECV_THROUGH_TEMP_FILE} ) 
#         };
#         if ( $@ ) {
#            push @errs, $@;
#            _debug 'caught ', $@ if _debugging;
#         }
#         if ( $close_it || $@ ) {
#            eval {
#               _close( $_->{TFD} );
#               $closed[$_->{TFD}] = 1;
#               $_->{TFD} = undef;
#            };
#            if ( $@ ) {
#               push @errs, $@;
#               _debug 'caught ', $@ if _debugging;
#            }
#         }
#      }
#   }
#confess "gak!" unless defined $self->{PIPES};
#
#   if ( @errs ) {
#      eval { $self->_cleanup };
#      warn $@ if $@;
#      die join( '', @errs );
#   }
#
#   $self->{STATE} = _started;
#   return $self;
#}
#
#
#sub adopt {
#   my IPC::Run $self = shift;
#
#   for my $adoptee ( @_ ) {
#      push @{$self->{IOS}},    @{$adoptee->{IOS}};
#      push @{$self->{KIDS}},   @{$adoptee->{KIDS}};
#      push @{$self->{PIPES}},  @{$adoptee->{PIPES}};
#      $self->{PTYS}->{$_} = $adoptee->{PTYS}->{$_}
#         for keys %{$adoptee->{PYTS}};
#      push @{$self->{TIMERS}}, @{$adoptee->{TIMERS}};
#      $adoptee->{STATE} = _finished;
#   }
#}
#
#
#sub _clobber {
#   my IPC::Run $self = shift;
#   my ( $file ) = @_;
#   _debug_desc_fd( "closing", $file ) if _debugging_details;
#   my $doomed = $file->{FD};
#   my $dir = $file->{TYPE} =~ /^</ ? 'WIN' : 'RIN';
#   vec( $self->{$dir}, $doomed, 1 ) = 0;
#   vec( $self->{PIN},  $doomed, 1 ) = 0;
#   if ( $file->{TYPE} =~ /^(.)pty.$/ ) {
#      if ( $1 eq '>' ) {
#         _debug_desc_fd "closing pty", $file if _debugging_details;
#         close $self->{PTYS}->{$file->{PTY_ID}}
#            if defined $self->{PTYS}->{$file->{PTY_ID}};
#         $self->{PTYS}->{$file->{PTY_ID}} = undef;
#      }
#   }
#   elsif ( UNIVERSAL::isa( $file, 'IPC::Run::IO' ) ) {
#      $file->close unless $file->{DONT_CLOSE};
#   }
#   else {
#      _close( $doomed );
#   }
#
#   @{$self->{PIPES}} = grep
#      defined $_->{FD} && ( $_->{TYPE} ne $file->{TYPE} || $_->{FD} ne $doomed),
#      @{$self->{PIPES}};
#
#   $file->{FD} = undef;
#}
#
#sub _select_loop {
#   my IPC::Run $self = shift;
#
#   my $io_occurred;
#
#   my $not_forever = 0.01;
#
#SELECT:
#   while ( $self->pumpable ) {
#      if ( $io_occurred && $self->{break_on_io} ) {
#         _debug "exiting _select(): io occured and break_on_io set"
#	    if _debugging_details;
#         last;
#      }
#
#      my $timeout = $self->{non_blocking} ? 0 : undef;
#
#      if ( @{$self->{TIMERS}} ) {
#         my $now = time;
#         my $time_left;
#         for ( @{$self->{TIMERS}} ) {
#            next unless $_->is_running;
#            $time_left = $_->check( $now );
#            return if defined $time_left && ! $time_left;
#            $timeout = $time_left
#               if ! defined $timeout || $time_left < $timeout;
#         }
#      }
#
#      my $paused = 0;
#
#      for my $file ( @{$self->{PIPES}} ) {
#         next unless $file->{PAUSED} && $file->{TYPE} =~ /^</;
#
#         _debug_desc_fd( "checking for more input", $file ) if _debugging_details;
#         my $did;
#         1 while $did = $file->_do_filters( $self );
#         if ( defined $file->{FD} && ! defined( $did ) || $did ) {
#            _debug_desc_fd( "unpausing", $file ) if _debugging_details;
#            $file->{PAUSED} = 0;
#            vec( $self->{WIN}, $file->{FD}, 1 ) = 1;
#            vec( $self->{PIN}, $file->{FD}, 1 ) = 0;
#         }
#         else {
#            ++$paused;
#         }
#      }
#
#      if ( _debugging_details ) {
#         my $map = join(
#            '',
#            map {
#               my $out;
#               $out = 'r'                     if vec( $self->{RIN}, $_, 1 );
#               $out = $out ? 'b' : 'w'        if vec( $self->{WIN}, $_, 1 );
#               $out = 'p'           if ! $out && vec( $self->{PIN}, $_, 1 );
#               $out = $out ? uc( $out ) : 'x' if vec( $self->{EIN}, $_, 1 );
#               $out = '-' unless $out;
#               $out;
#            } (0..1024)
#         );
#         $map =~ s/((?:[a-zA-Z-]|\([^\)]*\)){12,}?)-*$/$1/;
#         _debug 'fds for select: ', $map if _debugging_details;
#      }
#
#      my $p = $self->pumpable;
#      last unless $p;
#      if ( $p != 0  && ( ! defined $timeout || $timeout > 0.1 ) ) {
#	 $timeout = $not_forever;
#         $not_forever *= 2;
#         $not_forever = 0.5 if $not_forever >= 0.5;
#      }
#
#      if ( ! defined $timeout && ! ( @{$self->{PIPES}} - $paused ) ) {
#         if ( $self->{break_on_io} ) {
#	    _debug "exiting _select(): no I/O to do and timeout=forever"
#               if _debugging;
#	    last;
#	 }
#
#	 $timeout = $not_forever;
#         $not_forever *= 2;
#         $not_forever = 0.5 if $not_forever >= 0.5;
#      }
#
#      _debug 'timeout=', defined $timeout ? $timeout : 'forever'
#         if _debugging_details;
#
#      my $nfound;
#      unless ( Win32_MODE ) {
#         $nfound = select(
#            $self->{ROUT} = $self->{RIN},
#            $self->{WOUT} = $self->{WIN},
#            $self->{EOUT} = $self->{EIN},
#            $timeout 
#	 );
#      }
#      else {
#	 my @in = map $self->{$_}, qw( RIN WIN EIN );
#	 for ( @in ) {
#	    $_ = undef unless index( ( unpack "b*", $_ ), 1 ) >= 0;
#	 }
#
#	 $nfound = select(
#            $self->{ROUT} = $in[0],
#            $self->{WOUT} = $in[1],
#            $self->{EOUT} = $in[2],
#            $timeout 
#         );
#
#	 for ( $self->{ROUT}, $self->{WOUT}, $self->{EOUT} ) {
#	    $_ = "" unless defined $_;
#	 }
#      }
#      last if ! $nfound && $self->{non_blocking};
#
#      if ($nfound < 0) {
#         if ($! == POSIX::EINTR) {
#            $self->{ROUT} = $self->{WOUT} = $self->{EOUT} = '';
#            $nfound = 0;
#         }
#         else {
#            croak "$! in select";
#         }
#      }
#
#      if ( _debugging_details ) {
#         my $map = join(
#            '',
#            map {
#               my $out;
#               $out = 'r'                     if vec( $self->{ROUT}, $_, 1 );
#               $out = $out ? 'b' : 'w'        if vec( $self->{WOUT}, $_, 1 );
#               $out = $out ? uc( $out ) : 'x' if vec( $self->{EOUT}, $_, 1 );
#               $out = '-' unless $out;
#               $out;
#            } (0..128)
#         );
#         $map =~ s/((?:[a-zA-Z-]|\([^\)]*\)){12,}?)-*$/$1/;
#         _debug "selected  ", $map;
#      }
#
#      my @pipes = @{$self->{PIPES}};
#      $io_occurred = $_->poll( $self ) ? 1 : $io_occurred for @pipes;
#   }
#
#   return;
#}
#
#
#sub _cleanup {
#   my IPC::Run $self = shift;
#   _debug "cleaning up" if _debugging_details;
#
#   for ( values %{$self->{PTYS}} ) {
#      next unless ref $_;
#      eval {
#         _debug "closing slave fd ", fileno $_->slave if _debugging_data;
#         close $_->slave;
#      };
#      carp $@ . " while closing ptys" if $@;
#      eval {
#         _debug "closing master fd ", fileno $_ if _debugging_data;
#         close $_;
#      };
#      carp $@ . " closing ptys" if $@;
#   }
#   
#   _debug "cleaning up pipes" if _debugging_details;
#   $self->_clobber( $self->{PIPES}->[0] ) while @{$self->{PIPES}};
#
#   for my $kid ( @{$self->{KIDS}} ) {
#      _debug "cleaning up kid ", $kid->{NUM} if _debugging_details;
#      if ( ! length $kid->{PID} ) {
#         _debug 'never ran child ', $kid->{NUM}, ", can't reap"
#            if _debugging;
#         for my $op ( @{$kid->{OPS}} ) {
#            _close( $op->{TFD} )
#               if defined $op->{TFD} && ! defined $op->{TEMP_FILE_HANDLE};
#         }
#      }
#      elsif ( ! defined $kid->{RESULT} ) {
#         _debug 'reaping child ', $kid->{NUM}, ' (pid ', $kid->{PID}, ')'
#            if _debugging;
#         my $pid = waitpid $kid->{PID}, 0;
#         $kid->{RESULT} = $?;
#         _debug 'reaped ', $pid, ', $?=', $kid->{RESULT}
#            if _debugging;
#      }
#
#
#      _debug "cleaning up filters" if _debugging_details;
#      for my $op ( @{$kid->{OPS}} ) {
#         @{$op->{FILTERS}} = grep {
#            my $filter = $_;
#            ! grep $filter == $_, @{$self->{TEMP_FILTERS}};
#         } @{$op->{FILTERS}};
#      }
#
#      for my $op ( @{$kid->{OPS}} ) {
#         $op->_cleanup( $self ) if UNIVERSAL::isa( $op, "IPC::Run::IO" );
#      }
#   }
#   $self->{STATE} = _finished;
#   @{$self->{TEMP_FILTERS}} = ();
#   _debug "done cleaning up" if _debugging_details;
#
#   POSIX::close $self->{DEBUG_FD} if defined $self->{DEBUG_FD};
#   $self->{DEBUG_FD} = undef;
#}
#
#
#sub pump {
#   die "pump() takes only a a single harness as a parameter"
#      unless @_ == 1 && UNIVERSAL::isa( $_[0], __PACKAGE__ );
#
#   my IPC::Run $self = shift;
#
#   local $cur_self = $self;
#
#   _debug "** pumping" 
#      if _debugging;
#
#      $self->start if $self->{STATE} < _started;
#      croak "process ended prematurely" unless $self->pumpable;
#
#      $self->{auto_close_ins} = 0;
#      $self->{break_on_io}    = 1;
#      $self->_select_loop;
#      return $self->pumpable;
#}
#
#
#sub pump_nb {
#   my IPC::Run $self = shift;
#
#   $self->{non_blocking} = 1;
#   my $r = eval { $self->pump };
#   $self->{non_blocking} = 0;
#   die $@ if $@;
#   return $r;
#}
#
#
#sub pumpable {
#   my IPC::Run $self = shift;
#
#   return -1 if grep !$_->{PAUSED}, @{$self->{PIPES}};
#
#   $self->reap_nb;
#   return 0 unless $self->_running_kids;
#
#   select undef, undef, undef, 0.0001;
#
#   $self->reap_nb;
#   return 0 unless $self->_running_kids;
#
#   return -1; 
#}
#
#
#sub _running_kids {
#   my IPC::Run $self = shift;
#   return grep
#      defined $_->{PID} && ! defined $_->{RESULT},
#      @{$self->{KIDS}};
#}
#
#
#my $still_runnings;
#
#sub reap_nb {
#   my IPC::Run $self = shift;
#
#   local $cur_self = $self;
#
#   for my $kid ( @{$self->{KIDS}} ) {
#      if ( Win32_MODE ) {
#	 next if ! defined $kid->{PROCESS} || defined $kid->{RESULT};
#	 unless ( $kid->{PROCESS}->Wait( 0 ) ) {
#	    _debug "kid $kid->{NUM} ($kid->{PID}) still running"
#               if _debugging_details;
#	    next;
#	 }
#
#         _debug "kid $kid->{NUM} ($kid->{PID}) exited"
#            if _debugging;
#
#	 $kid->{PROCESS}->GetExitCode( $kid->{RESULT} )
#	    or croak "$! while GetExitCode()ing for Win32 process";
#
#	 unless ( defined $kid->{RESULT} ) {
#	    $kid->{RESULT} = "0 but true";
#	    $? = $kid->{RESULT} = 0x0F;
#	 }
#	 else {
#	    $? = $kid->{RESULT} << 8;
#	 }
#      }
#      else {
#	 next if ! defined $kid->{PID} || defined $kid->{RESULT};
#	 my $pid = waitpid $kid->{PID}, POSIX::WNOHANG();
#	 unless ( $pid ) {
#	    _debug "$kid->{NUM} ($kid->{PID}) still running"
#               if _debugging_details;
#	    next;
#	 }
#
#	 if ( $pid < 0 ) {
#	    _debug "No such process: $kid->{PID}\n" if _debugging;
#	    $kid->{RESULT} = "unknown result, unknown PID";
#	 }
#	 else {
#            _debug "kid $kid->{NUM} ($kid->{PID}) exited"
#               if _debugging;
#
#	    confess "waitpid returned the wrong PID: $pid instead of $kid->{PID}"
#	       unless $pid = $kid->{PID};
#	    _debug "$kid->{PID} returned $?\n" if _debugging;
#	    $kid->{RESULT} = $?;
#	 }
#      }
#   }
#}
#
#
#sub finish {
#   my IPC::Run $self = shift;
#   my $options = @_ && ref $_[-1] eq 'HASH' ? pop : {};
#
#   local $cur_self = $self;
#
#   _debug "** finishing" if _debugging;
#
#   $self->{non_blocking}   = 0;
#   $self->{auto_close_ins} = 1;
#   $self->{break_on_io}    = 0;
#
#   while ( $self->pumpable ) {
#      $self->_select_loop( $options );
#   }
#   $self->_cleanup;
#
#   return ! $self->full_result;
#}
#
#
#sub _assert_finished {
#   my IPC::Run $self = $_[0];
#
#   croak "Harness not run" unless $self->{STATE} >= _finished;
#   croak "Harness not finished running" unless $self->{STATE} == _finished;
#}
#
#
#sub result {
#   &_assert_finished;
#   my IPC::Run $self = shift;
#   
#   if ( @_ ) {
#      my ( $which ) = @_;
#      croak(
#         "Only ",
#         scalar( @{$self->{KIDS}} ),
#         " child processes, no process $which"
#      )
#         unless $which >= 0 && $which <= $#{$self->{KIDS}};
#      return $self->{KIDS}->[$which]->{RESULT} >> 8;
#   }
#   else {
#      return undef unless @{$self->{KIDS}};
#      for ( @{$self->{KIDS}} ) {
#         return $_->{RESULT} >> 8 if $_->{RESULT} >> 8;
#      }
#   }
#}
#
#
#sub results {
#   &_assert_finished;
#   my IPC::Run $self = shift;
#
#   return map { (0+$_->{RESULT}) >> 8 } @{$self->{KIDS}};
#}
#
#
#sub full_result {
#   goto &result if @_ > 1;
#   &_assert_finished;
#
#   my IPC::Run $self = shift;
#
#   return undef unless @{$self->{KIDS}};
#   for ( @{$self->{KIDS}} ) {
#      return $_->{RESULT} if $_->{RESULT};
#   }
#}
#
#
#sub full_results {
#   &_assert_finished;
#   my IPC::Run $self = shift;
#
#   croak "Harness not run" unless $self->{STATE} >= _finished;
#   croak "Harness not finished running" unless $self->{STATE} == _finished;
#
#   return map $_->{RESULT}, @{$self->{KIDS}};
#}
#
#
#use vars (
#   '$filter_op',        
#   '$filter_num',       
#);
#
#
#
#sub binary(;$) {
#   my $enable = @_ ? shift : 1;
#   return bless sub { $enable }, "IPC::Run::binmode_pseudo_filter";
#}
#
#
#sub new_chunker(;$) {
#   my ( $re ) = @_;
#   $re = $/ if _empty $re;
#   $re = quotemeta( $re ) unless ref $re eq 'Regexp';
#   $re = qr/\A(.*?$re)/s;
#
#   return sub {
#      my ( $in_ref, $out_ref ) = @_;
#
#      return 0 if length $$out_ref;
#
#      return input_avail && do {
#         while (1) {
#            if ( $$in_ref =~ s/$re// ) {
#               $$out_ref .= $1;
#               return 1;
#            }
#            my $hmm = get_more_input;
#            unless ( defined $hmm ) {
#               $$out_ref = $$in_ref;
#               $$in_ref = '';
#               return length $$out_ref ? 1 : 0;
#            }
#            return 0 if $hmm eq 0;
#         }
#      }
#   };
#}
#
#
#sub new_appender($) {
#   my ( $suffix ) = @_;
#   croak "\$suffix undefined" unless defined $suffix;
#
#   return sub {
#      my ( $in_ref, $out_ref ) = @_;
#
#      return input_avail && do {
#         $$out_ref = join( '', $$out_ref, $$in_ref, $suffix );
#         $$in_ref = '';
#         1;
#      }
#   };
#}
#
#
#
#sub new_string_source {
#   my $ref;
#   if ( @_ > 1 ) {
#      $ref = [ @_ ],
#   }
#   else {
#      $ref = shift;
#   }
#
#   return ref $ref eq 'SCALAR'
#      ? sub {
#         my ( $in_ref, $out_ref ) = @_;
#
#         return defined $$ref
#            ? do {
#               $$out_ref .= $$ref;
#               my $r = length $$ref ? 1 : 0;
#               $$ref = undef;
#               $r;
#            }
#            : undef
#      }
#      : sub {
#         my ( $in_ref, $out_ref ) = @_;
#
#         return @$ref
#            ? do {
#               my $s = shift @$ref;
#               $$out_ref .= $s;
#               length $s ? 1 : 0;
#            }
#            : undef;
#      }
#}
#
#
#sub new_string_sink {
#   my ( $string_ref ) = @_;
#
#   return sub {
#      my ( $in_ref, $out_ref ) = @_;
#
#      return input_avail && do {
#         $$string_ref .= $$in_ref;
#         $$in_ref = '';
#         1;
#      }
#   };
#}
#
#
#
#
#sub io {
#   require IPC::Run::IO;
#   IPC::Run::IO->new( @_ );
#}
#
#
#sub timer;
#*timer = \&IPC::Run::Timer::timer;
#
#
#sub timeout;
#*timeout = \&IPC::Run::Timer::timeout;
#
#
#sub input_avail() {
#   confess "Undefined FBUF ref for $filter_num+1"
#      unless defined $filter_op->{FBUFS}->[$filter_num+1];
#   length ${$filter_op->{FBUFS}->[$filter_num+1]} || get_more_input;
#}
#
#
#sub get_more_input() {
#   ++$filter_num;
#   my $r = eval {
#      confess "get_more_input() called and no more filters in chain"
#         unless defined $filter_op->{FILTERS}->[$filter_num];
#      $filter_op->{FILTERS}->[$filter_num]->(
#         $filter_op->{FBUFS}->[$filter_num+1],
#         $filter_op->{FBUFS}->[$filter_num],
#      ); 
#   };
#   --$filter_num;
#   die $@ if $@;
#   return $r;
#}
#
#1;
#
### IPC/Run/Debug.pm ###
#package IPC::Run::Debug;
#
#
#
#use strict;
#use Exporter;
#use vars qw{$VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS};
#BEGIN {
#	$VERSION = '0.90';
#	@ISA     = qw( Exporter );
#	@EXPORT  = qw(
#		_debug
#		_debug_desc_fd
#		_debugging
#		_debugging_data
#		_debugging_details
#		_debugging_gory_details
#		_debugging_not_optimized
#		_set_child_debug_name
#	);
#	
#	@EXPORT_OK = qw(
#		_debug_init
#		_debugging_level
#		_map_fds
#	);
#	%EXPORT_TAGS = (
#		default => \@EXPORT,
#		all     => [ @EXPORT, @EXPORT_OK ],
#	);
#}
#
#my $disable_debugging =
#   defined $ENV{IPCRUNDEBUG}
#   && (
#      ! $ENV{IPCRUNDEBUG}
#      || lc $ENV{IPCRUNDEBUG} eq "none"
#   );
#
#eval( $disable_debugging ? <<'STUBS' : <<'SUBS' ) or die $@;
#sub _map_fds()                 { "" }
#sub _debug                     {}
#sub _debug_desc_fd             {}
#sub _debug_init                {}
#sub _set_child_debug_name      {}
#sub _debugging()               { 0 }
#sub _debugging_level()         { 0 }
#sub _debugging_data()          { 0 }
#sub _debugging_details()       { 0 }
#sub _debugging_gory_details()  { 0 }
#sub _debugging_not_optimized() { 0 }
#
#1;
#STUBS
#
#use POSIX;
#
#sub _map_fds {
#   my $map = '';
#   my $digit = 0;
#   my $in_use;
#   my $dummy;
#   for my $fd (0..63) {
#      ## I'd like a quicker way (less user, cpu & expecially sys and kernal
#      ## calls) to detect open file descriptors.  Let me know...
#      ## Hmmm, could do a 0 length read and check for bad file descriptor...
#      ## but that segfaults on Win32
#      my $test_fd = POSIX::dup( $fd );
#      $in_use = defined $test_fd;
#      POSIX::close $test_fd if $in_use;
#      $map .= $in_use ? $digit : '-';
#      $digit = 0 if ++$digit > 9;
#   }
#   warn "No fds open???" unless $map =~ /\d/;
#   $map =~ s/(.{1,12})-*$/$1/;
#   return $map;
#}
#
#use vars qw( $parent_pid );
#
#$parent_pid = $$;
#
### TODO: move debugging to it's own module and make it compile-time
### optimizable.
#
### Give kid process debugging nice names
#my $debug_name;
#
#sub _set_child_debug_name {
#   $debug_name = shift;
#}
#
### There's a bit of hackery going on here.
###
### We want to have any code anywhere be able to emit
### debugging statements without knowing what harness the code is
### being called in/from, since we'd need to pass a harness around to
### everything.
###
### Thus, $cur_self was born.
##
#my %debug_levels = (
#   none    => 0,
#   basic   => 1,
#   data    => 2,
#   details => 3,
#   gore           => 4,
#   gory_details   => 4,
#   "gory details" => 4,
#   gory           => 4,
#   gorydetails    => 4,
#   all     => 10,
#   notopt  => 0,
#);
#
#my $warned;
#
#sub _debugging_level() {
#   my $level = 0;
#
#   $level = $IPC::Run::cur_self->{debug} || 0
#      if $IPC::Run::cur_self
#         && ( $IPC::Run::cur_self->{debug} || 0 ) >= $level;
#
#   if ( defined $ENV{IPCRUNDEBUG} ) {
#      my $v = $ENV{IPCRUNDEBUG};
#      $v = $debug_levels{lc $v} if $v =~ /[a-zA-Z]/;
#      unless ( defined $v ) {
#	 $warned ||= warn "Unknown debug level $ENV{IPCRUNDEBUG}, assuming 'basic' (1)\n";
#	 $v = 1;
#      }
#      $level = $v if $v > $level;
#   }
#   return $level;
#}
#
#sub _debugging_atleast($) {
#   my $min_level = shift || 1;
#
#   my $level = _debugging_level;
#   
#   return $level >= $min_level ? $level : 0;
#}
#
#sub _debugging()               { _debugging_atleast 1 }
#sub _debugging_data()          { _debugging_atleast 2 }
#sub _debugging_details()       { _debugging_atleast 3 }
#sub _debugging_gory_details()  { _debugging_atleast 4 }
#sub _debugging_not_optimized() { ( $ENV{IPCRUNDEBUG} || "" ) eq "notopt" }
#
#sub _debug_init {
#   ## This routine is called only in spawned children to fake out the
#   ## debug routines so they'll emit debugging info.
#   $IPC::Run::cur_self = {};
#   (  $parent_pid,
#      $^T, 
#      $IPC::Run::cur_self->{debug}, 
#      $IPC::Run::cur_self->{DEBUG_FD}, 
#      $debug_name 
#   ) = @_;
#}
#
#
#sub _debug {
##   return unless _debugging || _debugging_not_optimized;
#
#   my $fd = defined &IPC::Run::_debug_fd
#      ? IPC::Run::_debug_fd()
#      : fileno STDERR;
#
#   my $s;
#   my $debug_id;
#   $debug_id = join( 
#      " ",
#      join(
#         "",
#         defined $IPC::Run::cur_self ? "#$IPC::Run::cur_self->{ID}" : (),
#         "($$)",
#      ),
#      defined $debug_name && length $debug_name ? $debug_name        : (),
#   );
#   my $prefix = join(
#      "",
#      "IPC::Run",
#      sprintf( " %04d", time - $^T ),
#      ( _debugging_details ? ( " ", _map_fds ) : () ),
#      length $debug_id ? ( " [", $debug_id, "]" ) : (),
#      ": ",
#   );
#
#   my $msg = join( '', map defined $_ ? $_ : "<undef>", @_ );
#   chomp $msg;
#   $msg =~ s{^}{$prefix}gm;
#   $msg .= "\n";
#   POSIX::write( $fd, $msg, length $msg );
#}
#
#
#my @fd_descs = ( 'stdin', 'stdout', 'stderr' );
#
#sub _debug_desc_fd {
#   return unless _debugging;
#   my $text = shift;
#   my $op = pop;
#   my $kid = $_[0];
#
#Carp::carp join " ", caller(0), $text, $op  if defined $op  && UNIVERSAL::isa( $op, "IO::Pty" );
#
#   _debug(
#      $text,
#      ' ',
#      ( defined $op->{FD}
#         ? $op->{FD} < 3
#            ? ( $fd_descs[$op->{FD}] )
#            : ( 'fd ', $op->{FD} )
#         : $op->{FD}
#      ),
#      ( defined $op->{KFD}
#         ? (
#            ' (kid',
#            ( defined $kid ? ( ' ', $kid->{NUM}, ) : () ),
#            "'s ",
#            ( $op->{KFD} < 3
#               ? $fd_descs[$op->{KFD}]
#               : defined $kid
#                  && defined $kid->{DEBUG_FD}
#                  && $op->{KFD} == $kid->{DEBUG_FD}
#                  ? ( 'debug (', $op->{KFD}, ')' )
#                  : ( 'fd ', $op->{KFD} )
#            ),
#            ')',
#         )
#         : ()
#      ),
#   );
#}
#
#1;
#
#SUBS
#
### IPC/Run/IO.pm ###
#package IPC::Run::IO;
#
#
#
#use strict;
#use Carp;
#use Fcntl;
#use Symbol;
#
#use IPC::Run::Debug;
#use IPC::Run qw( Win32_MODE );
#
#use vars qw{$VERSION};
#BEGIN {
#	$VERSION = '0.90';
#	if ( Win32_MODE ) {
#		eval "use IPC::Run::Win32Helper; require IPC::Run::Win32IO; 1"
#		or ( $@ && die ) or die "$!";
#	}
#}
#
#sub _empty($);
#*_empty = \&IPC::Run::_empty;
#
#
#sub new {
#   my $class = shift;
#   $class = ref $class || $class;
#
#   my ( $external, $type, $internal ) = ( shift, shift, pop );
#
#   croak "$class: '$_' is not a valid I/O operator"
#      unless $type =~ /^(?:<<?|>>?)$/;
#
#   my IPC::Run::IO $self = $class->_new_internal(
#      $type, undef, undef, $internal, undef, @_
#   );
#
#   if ( ! ref $external ) {
#      $self->{FILENAME} = $external;
#   }
#   elsif ( ref eq 'GLOB' || UNIVERSAL::isa( $external, 'IO::Handle' ) ) {
#      $self->{HANDLE} = $external;
#      $self->{DONT_CLOSE} = 1;
#   }
#   else {
#      croak "$class: cannot accept " . ref( $external ) . " to do I/O with";
#   }
#
#   return $self;
#}
#
#
#sub _new_internal {
#   my $class = shift;
#   $class = ref $class || $class;
#
#   $class = "IPC::Run::Win32IO"
#      if Win32_MODE && $class eq "IPC::Run::IO";
#
#   my IPC::Run::IO $self;
#   $self = bless {}, $class;
#
#   my ( $type, $kfd, $pty_id, $internal, $binmode, @filters ) = @_;
#
#   $self->{TYPE}    = $type;
#   $self->{KFD}     = $kfd;
#   $self->{PTY_ID}  = $pty_id;
#   $self->binmode( $binmode );
#   $self->{FILTERS} = [ @filters ];
#
#   if ( $self->op =~ />/ ) {
#      croak "'$_' missing a destination" if _empty $internal;
#      $self->{DEST} = $internal;
#      if ( UNIVERSAL::isa( $self->{DEST}, 'CODE' ) ) {
#         unshift( 
#            @{$self->{FILTERS}},
#            sub {
#               my ( $in_ref ) = @_;
#
#               return IPC::Run::input_avail() && do {
#        	  $self->{DEST}->( $$in_ref );
#        	  $$in_ref = '';
#        	  1;
#               }
#            }
#         );
#      }
#   }
#   else {
#      croak "'$_' missing a source" if _empty $internal;
#      $self->{SOURCE} = $internal;
#      if ( UNIVERSAL::isa( $internal, 'CODE' ) ) {
#         push(
#            @{$self->{FILTERS}},
#            sub {
#               my ( $in_ref, $out_ref ) = @_;
#               return 0 if length $$out_ref;
#
#               return undef
#        	  if $self->{SOURCE_EMPTY};
#
#               my $in = $internal->();
#               unless ( defined $in ) {
#        	  $self->{SOURCE_EMPTY} = 1;
#        	  return undef 
#               }
#               return 0 unless length $in;
#               $$out_ref = $in;
#
#               return 1;
#            }
#         );
#      }
#      elsif ( UNIVERSAL::isa( $internal, 'SCALAR' ) ) {
#         push(
#            @{$self->{FILTERS}},
#            sub {
#               my ( $in_ref, $out_ref ) = @_;
#               return 0 if length $$out_ref;
#
#               return $self->{HARNESS}->{auto_close_ins} ? undef : 0
#        	  if IPC::Run::_empty ${$self->{SOURCE}}
#        	     || $self->{SOURCE_EMPTY};
#
#               $$out_ref = $$internal;
#               eval { $$internal = '' }
#        	  if $self->{HARNESS}->{clear_ins};
#
#               $self->{SOURCE_EMPTY} = $self->{HARNESS}->{auto_close_ins};
#
#               return 1;
#            }
#         );
#      }
#   }
#
#   return $self;
#}
#
#
#sub filename {
#   my IPC::Run::IO $self = shift;
#   $self->{FILENAME} = shift if @_;
#   return $self->{FILENAME};
#}
#
#
#sub init {
#   my IPC::Run::IO $self = shift;
#
#   $self->{SOURCE_EMPTY} = 0;
#   ${$self->{DEST}} = ''
#      if $self->mode =~ /r/ && ref $self->{DEST} eq 'SCALAR';
#
#   $self->open if defined $self->filename;
#   $self->{FD} = $self->fileno;
#
#   if ( ! $self->{FILTERS} ) {
#      $self->{FBUFS} = undef;
#   }
#   else {
#      @{$self->{FBUFS}} = map {
#         my $s = "";
#         \$s;
#      } ( @{$self->{FILTERS}}, '' );
#
#      $self->{FBUFS}->[0] = $self->{DEST}
#         if $self->{DEST} && ref $self->{DEST} eq 'SCALAR';
#      push @{$self->{FBUFS}}, $self->{SOURCE};
#   }
#
#   return undef;
#}
#
#
#
#my %open_flags = (
#   '>'  => O_RDONLY,
#   '>>' => O_RDONLY,
#   '<'  => O_WRONLY | O_CREAT | O_TRUNC,
#   '<<' => O_WRONLY | O_CREAT | O_APPEND,
#);
#
#sub open {
#   my IPC::Run::IO $self = shift;
#
#   croak "IPC::Run::IO: Can't open() a file with no name"
#      unless defined $self->{FILENAME};
#   $self->{HANDLE} = gensym unless $self->{HANDLE};
#
#   _debug
#      "opening '", $self->filename, "' mode '", $self->mode, "'"
#   if _debugging_data;
#   sysopen(
#      $self->{HANDLE},
#      $self->filename,
#      $open_flags{$self->op},
#   ) or croak
#         "IPC::Run::IO: $! opening '$self->{FILENAME}', mode '" . $self->mode . "'";
#
#   return undef;
#}
#
#
#
#sub _do_open {
#   my $self = shift;
#   my ( $child_debug_fd, $parent_handle ) = @_;
#
#
#   if ( $self->dir eq "<" ) {
#      ( $self->{TFD}, $self->{FD} ) = IPC::Run::_pipe_nb;
#      if ( $parent_handle ) {
#         CORE::open $parent_handle, ">&=$self->{FD}"
#            or croak "$! duping write end of pipe for caller";
#      }
#   }
#   else {
#      ( $self->{FD}, $self->{TFD} ) = IPC::Run::_pipe;
#      if ( $parent_handle ) {
#         CORE::open $parent_handle, "<&=$self->{FD}"
#            or croak "$! duping read end of pipe for caller";
#      }
#   }
#}
#
#sub open_pipe {
#   my IPC::Run::IO $self = shift;
#
#   croak "IPC::Run::IO: Can't pipe() when a file name has been set"
#      if defined $self->{FILENAME};
#
#   $self->_do_open( @_ );
#
#   return $self->dir eq "<"
#      ? ( $self->{TFD}, $self->{FD} )
#      : ( $self->{FD}, $self->{TFD} );
#}
#
#
#sub _cleanup { 
#   my $self = shift;
#   undef $self->{FAKE_PIPE};
#}
#
#
#
#sub close {
#   my IPC::Run::IO $self = shift;
#
#   if ( defined $self->{HANDLE} ) {
#      close $self->{HANDLE}
#         or croak(  "IPC::Run::IO: $! closing "
#            . ( defined $self->{FILENAME}
#               ? "'$self->{FILENAME}'"
#               : "handle"
#            )
#         );
#   }
#   else {
#      IPC::Run::_close( $self->{FD} );
#   }
#
#   $self->{FD} = undef;
#
#   return undef;
#}
#
#
#sub fileno {
#   my IPC::Run::IO $self = shift;
#
#   my $fd = fileno $self->{HANDLE};
#   croak(  "IPC::Run::IO: $! "
#         . ( defined $self->{FILENAME}
#            ? "'$self->{FILENAME}'"
#            : "handle"
#         )
#      ) unless defined $fd;
#
#   return $fd;
#}
#
#
#sub mode {
#   my IPC::Run::IO $self = shift;
#
#   croak "IPC::Run::IO: unexpected arguments for mode(): @_" if @_;
#
#   return ( $self->{TYPE} =~ /</     ? 'w' : 'r' ) . 
#          ( $self->{TYPE} =~ /<<|>>/ ? 'a' : ''  );
#}
#
#
#
#sub op {
#   my IPC::Run::IO $self = shift;
#
#   croak "IPC::Run::IO: unexpected arguments for op(): @_" if @_;
#
#   return $self->{TYPE};
#}
#
#
#sub binmode {
#   my IPC::Run::IO $self = shift;
#
#   $self->{BINMODE} = shift if @_;
#
#   return $self->{BINMODE};
#}
#
#
#
#sub dir {
#   my IPC::Run::IO $self = shift;
#
#   croak "IPC::Run::IO: unexpected arguments for dir(): @_" if @_;
#
#   return substr $self->{TYPE}, 0, 1;
#}
#
#
#
#use vars (
#'$filter_op',        
#'$filter_num'        
#);
#
#sub _init_filters {
#   my IPC::Run::IO $self = shift;
#
#confess "\$self not an IPC::Run::IO" unless UNIVERSAL::isa( $self, "IPC::Run::IO" );
#   $self->{FBUFS} = [];
#
#   $self->{FBUFS}->[0] = $self->{DEST}
#      if $self->{DEST} && ref $self->{DEST} eq 'SCALAR';
#
#   return unless $self->{FILTERS} && @{$self->{FILTERS}};
#
#   push @{$self->{FBUFS}}, map {
#      my $s = "";
#      \$s;
#   } ( @{$self->{FILTERS}}, '' );
#
#   push @{$self->{FBUFS}}, $self->{SOURCE};
#}
#
#
#sub poll {
#   my IPC::Run::IO $self = shift;
#   my ( $harness ) = @_;
#
#   if ( defined $self->{FD} ) {
#      my $d = $self->dir;
#      if ( $d eq "<" ) {
#         if ( vec $harness->{WOUT}, $self->{FD}, 1 ) {
#            _debug_desc_fd( "filtering data to", $self )
#               if _debugging_details;
#            return $self->_do_filters( $harness );
#         }
#      }
#      elsif ( $d eq ">" ) {
#         if ( vec $harness->{ROUT}, $self->{FD}, 1 ) {
#            _debug_desc_fd( "filtering data from", $self )
#               if _debugging_details;
#            return $self->_do_filters( $harness );
#         }
#      }
#   }
#   return 0;
#}
#
#
#sub _do_filters {
#   my IPC::Run::IO $self = shift;
#
#   ( $self->{HARNESS} ) = @_;
#
#   my ( $saved_op, $saved_num ) =($IPC::Run::filter_op,$IPC::Run::filter_num);
#   $IPC::Run::filter_op = $self;
#   $IPC::Run::filter_num = -1;
#   my $redos = 0;
#   my $r;
#   {
#	   $@ = '';
#	   $r = eval { IPC::Run::get_more_input(); };
#
#	   if(($@||'') =~ $IPC::Run::_EAGAIN && $redos++ < 200) {
#	       select(undef, undef, undef, 0.01);
#	       redo;
#	   }
#   }
#   ( $IPC::Run::filter_op, $IPC::Run::filter_num ) = ( $saved_op, $saved_num );
#   $self->{HARNESS} = undef;
#   die "ack ", $@ if $@;
#   return $r;
#}
#
#
#1;
### IPC/Run/Timer.pm ###
#package IPC::Run::Timer;
#
#
#use strict;
#use Carp;
#use Fcntl;
#use Symbol;
#use Exporter;
#use vars qw( $VERSION @ISA @EXPORT_OK %EXPORT_TAGS );
#BEGIN {
#	$VERSION   = '0.90';
#	@ISA       = qw( Exporter );
#	@EXPORT_OK = qw(
#		check
#		end_time
#		exception
#		expire
#		interval
#		is_expired
#		is_reset
#		is_running
#		name
#		reset
#		start
#		timeout
#		timer
#	);
#
#	%EXPORT_TAGS = ( 'all' => \@EXPORT_OK );
#}
#
#require IPC::Run;
#use IPC::Run::Debug;
#
#my $resolution = 1;
#
#sub _parse_time {
#   for ( $_[0] ) {
#      return $_ unless defined $_;
#      return $_ if /^\d*(?:\.\d*)?$/;
#
#      my @f = reverse split( /[^\d\.]+/i );
#      croak "IPC::Run: invalid time string '$_'" unless @f <= 4;
#      my ( $s, $m, $h, $d ) = @f;
#      return
#      ( (
#	         ( $d || 0 )   * 24
#	       + ( $h || 0 ) ) * 60
#	       + ( $m || 0 ) ) * 60
#               + ( $s || 0 );
#   }
#}
#
#sub _calc_end_time {
#   my IPC::Run::Timer $self = shift;
#   my $interval = $self->interval;
#   $interval += $resolution if $interval;
#   $self->end_time( $self->start_time + $interval );
#}
#
#
#
#sub timer {
#   return IPC::Run::Timer->new( @_ );
#}
#
#
#
#sub timeout {
#   my $t = IPC::Run::Timer->new( @_ );
#   $t->exception( "IPC::Run: timeout on " . $t->name )
#      unless defined $t->exception;
#   return $t;
#}
#
#
#
#my $timer_counter;
#
#
#sub new {
#   my $class = shift;
#   $class = ref $class || $class;
#
#   my IPC::Run::Timer $self = bless {}, $class;
#
#   $self->{STATE} = 0;
#   $self->{DEBUG} = 0;
#   $self->{NAME}  = "timer #" . ++$timer_counter;
#
#   while ( @_ ) {
#      my $arg = shift;
#      if ( $arg =~ /^(?:\d+[^\a\d]){0,3}\d*(?:\.\d*)?$/ ) {
#         $self->interval( $arg );
#      }
#      elsif ( $arg eq 'exception' ) {
#         $self->exception( shift );
#      }
#      elsif ( $arg eq 'name' ) {
#         $self->name( shift );
#      }
#      elsif ( $arg eq 'debug' ) {
#         $self->debug( shift );
#      }
#      else {
#         croak "IPC::Run: unexpected parameter '$arg'";
#      }
#   }
#
#   _debug $self->name . ' constructed'
#      if $self->{DEBUG} || _debugging_details;
#
#   return $self;
#}
#
#
#sub check {
#   my IPC::Run::Timer $self = shift;
#   return undef if ! $self->is_running;
#   return 0     if  $self->is_expired;
#
#   my ( $now ) = @_;
#   $now = _parse_time( $now );
#   $now = time unless defined $now;
#
#   _debug(
#      "checking ", $self->name, " (end time ", $self->end_time, ") at ", $now 
#   ) if $self->{DEBUG} || _debugging_details;
#
#   my $left = $self->end_time - $now;
#   return $left if $left > 0;
#
#   $self->expire;
#   return 0;
#}
#
#
#
#
#sub debug {
#   my IPC::Run::Timer $self = shift;
#   $self->{DEBUG} = shift if @_;
#   return $self->{DEBUG};
#}
#
#
#
#
#sub end_time {
#   my IPC::Run::Timer $self = shift;
#   if ( @_ ) {
#      $self->{END_TIME} = shift;
#      _debug $self->name, ' end_time set to ', $self->{END_TIME}
#	 if $self->{DEBUG} > 2 || _debugging_details;
#   }
#   return $self->{END_TIME};
#}
#
#
#
#
#sub exception {
#   my IPC::Run::Timer $self = shift;
#   if ( @_ ) {
#      $self->{EXCEPTION} = shift;
#      _debug $self->name, ' exception set to ', $self->{EXCEPTION}
#	 if $self->{DEBUG} || _debugging_details;
#   }
#   return $self->{EXCEPTION};
#}
#
#
#
#sub interval {
#   my IPC::Run::Timer $self = shift;
#   if ( @_ ) {
#      $self->{INTERVAL} = _parse_time( shift );
#      _debug $self->name, ' interval set to ', $self->{INTERVAL}
#	 if $self->{DEBUG} > 2 || _debugging_details;
#
#      $self->_calc_end_time if $self->state;
#   }
#   return $self->{INTERVAL};
#}
#
#
#
#
#sub expire {
#   my IPC::Run::Timer $self = shift;
#   if ( defined $self->state ) {
#      _debug $self->name . ' expired'
#	 if $self->{DEBUG} || _debugging;
#
#      $self->state( undef );
#      croak $self->exception if $self->exception;
#   }
#   return undef;
#}
#
#
#
#
#sub is_running {
#   my IPC::Run::Timer $self = shift;
#   return $self->state ? 1 : 0;
#}
#
#
#   
#sub is_reset {
#   my IPC::Run::Timer $self = shift;
#   return defined $self->state && $self->state == 0;
#}
#
#
#
#sub is_expired {
#   my IPC::Run::Timer $self = shift;
#   return ! defined $self->state;
#}
#
#
#sub name {
#   my IPC::Run::Timer $self = shift;
# 
#   $self->{NAME} = shift if @_;
#   return defined $self->{NAME}
#      ? $self->{NAME}
#      : defined $self->{EXCEPTION}
#         ? 'timeout'
#	 : 'timer';
#}
#
#
#
#sub reset {
#   my IPC::Run::Timer $self = shift;
#   $self->state( 0 );
#   $self->end_time( undef );
#   _debug $self->name . ' reset'
#      if $self->{DEBUG} || _debugging;
#
#   return undef;
#}
#
#
#
#sub start {
#   my IPC::Run::Timer $self = shift;
#
#   my ( $interval, $now ) = map { _parse_time( $_ ) } @_;
#   $now = _parse_time( $now );
#   $now = time unless defined $now;
#
#   $self->interval( $interval ) if defined $interval;
#
#   $self->end_time( undef ) if ! $self->is_reset || $interval;
#
#   croak "IPC::Run: no timer interval or end_time defined for " . $self->name
#      unless defined $self->interval || defined $self->end_time;
#
#   $self->state( 1 );
#   $self->start_time( $now );
#   $self->_calc_end_time
#      unless defined $self->end_time;
#
#   _debug(
#      $self->name, " started at ", $self->start_time,
#      ", with interval ", $self->interval, ", end_time ", $self->end_time
#   ) if $self->{DEBUG} || _debugging;
#   return undef;
#}
#
#
#
#
#sub start_time {
#   my IPC::Run::Timer $self = shift;
#   if ( @_ ) {
#      $self->{START_TIME} = _parse_time( shift );
#      _debug $self->name, ' start_time set to ', $self->{START_TIME}
#	 if $self->{DEBUG} > 2 || _debugging;
#   }
#
#   return $self->{START_TIME};
#}
#
#
#
#sub state {
#   my IPC::Run::Timer $self = shift;
#   if ( @_ ) {
#      $self->{STATE} = shift;
#      _debug $self->name, ' state set to ', $self->{STATE}
#	 if $self->{DEBUG} > 2 || _debugging;
#   }
#   return $self->{STATE};
#}
#
#
#1;
#
### IPC/Run/Win32Helper.pm ###
#package IPC::Run::Win32Helper;
#
#
#use strict;
#use Carp;
#use IO::Handle;
#use vars qw{ $VERSION @ISA @EXPORT };
#BEGIN {
#	$VERSION = '0.90';
#	@ISA = qw( Exporter );
#	@EXPORT = qw(
#		win32_spawn
#		win32_parse_cmd_line
#		_dont_inherit
#		_inherit
#	);
#}
#
#require POSIX;
#
#use Text::ParseWords;
#use Win32::Process;
#use IPC::Run::Debug;
#use Win32API::File qw(
#   FdGetOsFHandle
#   SetHandleInformation
#   HANDLE_FLAG_INHERIT
#   INVALID_HANDLE_VALUE
#);
#
#sub _dont_inherit {
#   for ( @_ ) {
#      next unless defined $_;
#      my $fd = $_;
#      $fd = fileno $fd if ref $fd;
#      _debug "disabling inheritance of ", $fd if _debugging_details;
#      my $osfh = FdGetOsFHandle $fd;
#      croak $^E if ! defined $osfh || $osfh == INVALID_HANDLE_VALUE;
#
#      SetHandleInformation( $osfh, HANDLE_FLAG_INHERIT, 0 );
#   }
#}
#
#sub _inherit {       
#   for ( @_ ) {       
#      next unless defined $_;       
#      my $fd = $_;       
#      $fd = fileno $fd if ref $fd;       
#      _debug "enabling inheritance of ", $fd if _debugging_details;       
#      my $osfh = FdGetOsFHandle $fd;       
#      croak $^E if ! defined $osfh || $osfh == INVALID_HANDLE_VALUE;       
#      SetHandleInformation( $osfh, HANDLE_FLAG_INHERIT, 1 );       
#   }       
#}       
#
#
#sub optimize {
#   my ( $h ) = @_;
#
#   my @kids = @{$h->{KIDS}};
#
#   my $saw_pipe;
#
#   my ( $ok_to_optimize_outputs, $veto_output_optimization );
#
#   for my $kid ( @kids ) {
#      ( $ok_to_optimize_outputs, $veto_output_optimization ) = ()
#         unless $saw_pipe;
#
#      _debug
#         "Win32 optimizer: (kid $kid->{NUM}) STDIN piped, carrying over ok of non-SCALAR output optimization"
#         if _debugging_details && $ok_to_optimize_outputs;
#      _debug
#         "Win32 optimizer: (kid $kid->{NUM}) STDIN piped, carrying over veto of non-SCALAR output optimization"
#         if _debugging_details && $veto_output_optimization;
#
#      if ( $h->{noinherit} && ! $ok_to_optimize_outputs ) {
#	 _debug
#	    "Win32 optimizer: (kid $kid->{NUM}) STDIN not inherited from parent oking non-SCALAR output optimization"
#	    if _debugging_details && $ok_to_optimize_outputs;
#	 $ok_to_optimize_outputs = 1;
#      }
#
#      for ( @{$kid->{OPS}} ) {
#         if ( substr( $_->{TYPE}, 0, 1 ) eq "<" ) {
#            if ( $_->{TYPE} eq "<" ) {
#	       if ( @{$_->{FILTERS}} > 1 ) {
#	       }
#               elsif ( ref $_->{SOURCE} eq "SCALAR"
#	          || ref $_->{SOURCE} eq "GLOB"
#		  || UNIVERSAL::isa( $_, "IO::Handle" )
#	       ) {
#                  if ( $_->{KFD} == 0 ) {
#                     _debug
#                        "Win32 optimizer: (kid $kid->{NUM}) 0$_->{TYPE}",
#                        ref $_->{SOURCE},
#                        ", ok to optimize outputs"
#                        if _debugging_details;
#                     $ok_to_optimize_outputs = 1;
#                  }
#                  $_->{SEND_THROUGH_TEMP_FILE} = 1;
#                  next;
#               }
#               elsif ( ! ref $_->{SOURCE} && defined $_->{SOURCE} ) {
#                  if ( $_->{KFD} == 0 ) {
#                     _debug
#                        "Win32 optimizer: (kid $kid->{NUM}) 0<$_->{SOURCE}, ok to optimize outputs",
#                        if _debugging_details;
#                     $ok_to_optimize_outputs = 1;
#                  }
#                  next;
#               }
#            }
#            _debug
#               "Win32 optimizer: (kid $kid->{NUM}) ",
#               $_->{KFD},
#               $_->{TYPE},
#               defined $_->{SOURCE}
#                  ? ref $_->{SOURCE}      ? ref $_->{SOURCE}
#                                          : $_->{SOURCE}
#                  : defined $_->{FILENAME}
#                                          ? $_->{FILENAME}
#                                          : "",
#	       @{$_->{FILTERS}} > 1 ? " with filters" : (),
#               ", VETOING output opt."
#               if _debugging_details || _debugging_not_optimized;
#            $veto_output_optimization = 1;
#         }
#         elsif ( $_->{TYPE} eq "close" && $_->{KFD} == 0 ) {
#            $ok_to_optimize_outputs = 1;
#            _debug "Win32 optimizer: (kid $kid->{NUM}) saw 0<&-, ok to optimize outputs"
#               if _debugging_details;
#         }
#         elsif ( $_->{TYPE} eq "dup" && $_->{KFD2} == 0 ) {
#            $veto_output_optimization = 1;
#            _debug "Win32 optimizer: (kid $kid->{NUM}) saw 0<&$_->{KFD2}, VETOING output opt."
#               if _debugging_details || _debugging_not_optimized;
#         }
#         elsif ( $_->{TYPE} eq "|" ) {
#            $saw_pipe = 1;
#         }
#      }
#
#      if ( ! $ok_to_optimize_outputs && ! $veto_output_optimization ) {
#         _debug
#            "Win32 optimizer: (kid $kid->{NUM}) child STDIN not redirected, VETOING non-SCALAR output opt."
#            if _debugging_details || _debugging_not_optimized;
#         $veto_output_optimization = 1;
#      }
#
#      if ( $ok_to_optimize_outputs && $veto_output_optimization ) {
#         $ok_to_optimize_outputs = 0;
#         _debug "Win32 optimizer: (kid $kid->{NUM}) non-SCALAR output optimizations VETOed"
#            if _debugging_details || _debugging_not_optimized;
#      }
#
#
#      for ( @{$kid->{OPS}} ) {
#         if ( $_->{TYPE} eq ">" ) {
#            if ( ref $_->{DEST} eq "SCALAR"
#               || (
#                  ( @{$_->{FILTERS}} > 1
#		     || ref $_->{DEST} eq "CODE"
#		     || ref $_->{DEST} eq "ARRAY"  
#	          )
#                  && ( $ok_to_optimize_outputs && ! $veto_output_optimization ) 
#               )
#            ) {
#	       $_->{RECV_THROUGH_TEMP_FILE} = 1;
#	       next;
#            }
#	    _debug
#	       "Win32 optimizer: NOT optimizing (kid $kid->{NUM}) ",
#	       $_->{KFD},
#	       $_->{TYPE},
#	       defined $_->{DEST}
#		  ? ref $_->{DEST}      ? ref $_->{DEST}
#					  : $_->{SOURCE}
#		  : defined $_->{FILENAME}
#					  ? $_->{FILENAME}
#					  : "",
#		  @{$_->{FILTERS}} ? " with filters" : (),
#	       if _debugging_details;
#         }
#      }
#   }
#
#}
#
#
#sub win32_parse_cmd_line {
#   my $line = shift;
#   $line =~ s{(\\[\w\s])}{\\$1}g;
#   return shellwords $line;
#}
#
#
#sub _save {
#   my ( $saved, $saved_as, $fd ) = @_;
#
#   return if exists $saved->{$fd};
#
#   my $saved_fd = IPC::Run::_dup( $fd );
#   _dont_inherit $saved_fd;
#
#   $saved->{$fd} = $saved_fd;
#   $saved_as->{$saved_fd} = $fd;
#
#   _dont_inherit $saved->{$fd};
#}
#
#sub _dup2_gently {
#   my ( $saved, $saved_as, $fd1, $fd2 ) = @_;
#   _save $saved, $saved_as, $fd2;
#
#   if ( exists $saved_as->{$fd2} ) {
#      my $orig_fd = delete $saved_as->{$fd2};
#      my $saved_fd = IPC::Run::_dup( $fd2 );
#      _dont_inherit $saved_fd;
#
#      $saved->{$orig_fd} = $saved_fd;
#      $saved_as->{$saved_fd} = $orig_fd;
#   }
#   _debug "moving $fd1 to kid's $fd2" if _debugging_details;
#   IPC::Run::_dup2_rudely( $fd1, $fd2 );
#}
#
#sub win32_spawn {
#   my ( $cmd, $ops) = @_;
#
#   
#   my %saved;      
#   my %saved_as;   
#   
#   for my $op ( @$ops ) {
#      _dont_inherit $op->{FD}  if defined $op->{FD};
#
#      if ( defined $op->{KFD} && $op->{KFD} > 2 ) {
#         croak "Can't redirect fd #", $op->{KFD}, " on Win32";
#      }
#
#      if ( defined $op->{TFD} ) {
#	 unless ( $op->{TFD} == $op->{KFD} ) {
#	    _dup2_gently \%saved, \%saved_as, $op->{TFD}, $op->{KFD};
#	    _dont_inherit $op->{TFD};
#	 }
#      }
#      elsif ( $op->{TYPE} eq "dup" ) {
#         _dup2_gently \%saved, \%saved_as, $op->{KFD1}, $op->{KFD2}
#            unless $op->{KFD1} == $op->{KFD2};
#      }
#      elsif ( $op->{TYPE} eq "close" ) {
#	 _save \%saved, \%saved_as, $op->{KFD};
#	 IPC::Run::_close( $op->{KFD} );
#      }
#      elsif ( $op->{TYPE} eq "init" ) {
#         croak "init subs not allowed on Win32";
#      }
#   }
#
#   my $process;
#   my $cmd_line = join " ", map {
#      ( my $s = $_ ) =~ s/"/"""/g;
#      $s = qq{"$s"} if /[\"\s]|^$/;
#      $s;
#   } @$cmd;
#
#   _debug "cmd line: ", $cmd_line
#      if _debugging;
#
#   Win32::Process::Create( 
#      $process,
#      $cmd->[0],
#      $cmd_line,
#      1,  
#      NORMAL_PRIORITY_CLASS,
#      ".",
#   ) or croak "$!: Win32::Process::Create()";
#
#   for my $orig_fd ( keys %saved ) {
#      IPC::Run::_dup2_rudely( $saved{$orig_fd}, $orig_fd );
#      IPC::Run::_close( $saved{$orig_fd} );
#   }
#
#   return ( $process->GetProcessID(), $process );
#}
#
#
#1;
#
### IPC/Run/Win32IO.pm ###
#package IPC::Run::Win32IO;
#
#
#use strict;
#use Carp;
#use IO::Handle;
#use Socket;
#require POSIX;
#
#use vars qw{$VERSION};
#BEGIN {
#	$VERSION = '0.90';
#}
#
#use Socket qw( IPPROTO_TCP TCP_NODELAY );
#use Symbol;
#use Text::ParseWords;
#use Win32::Process;
#use IPC::Run::Debug qw( :default _debugging_level );
#use IPC::Run::Win32Helper qw( _inherit _dont_inherit );
#use Fcntl qw( O_TEXT O_RDONLY );
#
#use base qw( IPC::Run::IO );
#my @cleanup_fields;
#BEGIN {
#   @cleanup_fields = (
#      'SEND_THROUGH_TEMP_FILE', 
#      'RECV_THROUGH_TEMP_FILE', 
#      'TEMP_FILE_NAME',         
#
#      'PARENT_HANDLE',       
#      'PUMP_SOCKET_HANDLE',  
#      'PUMP_PIPE_HANDLE',    
#      'CHILD_HANDLE',        
#
#      'TEMP_FILE_HANDLE',    
#   );
#}
#
#use Win32API::File qw(
#   GetOsFHandle
#   OsFHandleOpenFd
#   OsFHandleOpen
#   FdGetOsFHandle
#   SetHandleInformation
#   SetFilePointer
#   HANDLE_FLAG_INHERIT
#   INVALID_HANDLE_VALUE
#
#   createFile
#   WriteFile
#   ReadFile
#   CloseHandle
#
#   FILE_ATTRIBUTE_TEMPORARY
#   FILE_FLAG_DELETE_ON_CLOSE
#   FILE_FLAG_WRITE_THROUGH
#
#   FILE_BEGIN
#);
#
#
#
#BEGIN {
#   () = (
#      SOL_SOCKET,
#      SO_REUSEADDR,
#      IPPROTO_TCP,
#      TCP_NODELAY,
#      HANDLE_FLAG_INHERIT,
#      INVALID_HANDLE_VALUE,
#   );
#}
#
#use constant temp_file_flags => (
#   FILE_ATTRIBUTE_TEMPORARY()   |
#   FILE_FLAG_DELETE_ON_CLOSE()  |
#   FILE_FLAG_WRITE_THROUGH()
#);
#
#my $tmp_file_counter;
#my $tmp_dir;
#
#sub _cleanup {
#    my IPC::Run::Win32IO $self = shift;
#    my ( $harness ) = @_;
#
#    $self->_recv_through_temp_file( $harness )
#       if $self->{RECV_THROUGH_TEMP_FILE};
#
#    CloseHandle( $self->{TEMP_FILE_HANDLE} )
#       if defined $self->{TEMP_FILE_HANDLE};
#
#    $self->{$_} = undef for @cleanup_fields;
#}
#
#
#sub _create_temp_file {
#   my IPC::Run::Win32IO $self = shift;
#
#   unless ( defined $tmp_dir ) {
#      $tmp_dir = File::Spec->catdir(
#         File::Spec->tmpdir, "IPC-Run.tmp"
#      );
#
#      unless ( -d $tmp_dir ) {
#         mkdir $tmp_dir or croak "$!: $tmp_dir";
#      }
#   }
#
#   $self->{TEMP_FILE_NAME} = File::Spec->catfile(
#      $tmp_dir, sprintf "Win32io-%06d-%08d", $$, $tmp_file_counter++
#   );
#
#   $self->{TEMP_FILE_HANDLE} = createFile(
#      $self->{TEMP_FILE_NAME},
#      "trw",         
#      {
#         Flags      => temp_file_flags,
#      },
#   ) or croak "Can't create temporary file, $self->{TEMP_FILE_NAME}: $^E";
#
#   $self->{TFD} = OsFHandleOpenFd $self->{TEMP_FILE_HANDLE}, 0;
#   $self->{FD} = undef;
#
#   _debug
#      "Win32 Optimizer: temp file (",
#      $self->{KFD},
#      $self->{TYPE},
#      $self->{TFD},
#      ", fh ",
#      $self->{TEMP_FILE_HANDLE},
#      "): ",
#      $self->{TEMP_FILE_NAME}
#      if _debugging_details;
#}
#
#
#sub _reset_temp_file_pointer {
#   my $self = shift;
#   SetFilePointer( $self->{TEMP_FILE_HANDLE}, 0, 0, FILE_BEGIN )
#      or confess "$^E seeking on (fd $self->{TFD}) $self->{TEMP_FILE_NAME} for kid's fd $self->{KFD}";
#}
#
#
#sub _send_through_temp_file {
#   my IPC::Run::Win32IO $self = shift;
#
#   _debug
#      "Win32 optimizer: optimizing "
#      . " $self->{KFD} $self->{TYPE} temp file instead of ",
#         ref $self->{SOURCE} || $self->{SOURCE}
#      if _debugging_details;
#
#   $self->_create_temp_file;
#
#   if ( defined ${$self->{SOURCE}} ) {
#      my $bytes_written = 0;
#      my $data_ref;
#      if ( $self->binmode ) {
#	 $data_ref = $self->{SOURCE};
#      }
#      else {
#         my $data = ${$self->{SOURCE}};  
#	 $data =~ s/(?<!\r)\n/\r\n/g;
#	 $data_ref = \$data;
#      }
#
#      WriteFile(
#         $self->{TEMP_FILE_HANDLE},
#         $$data_ref,
#         0,              
#         $bytes_written,
#         [],             
#      ) or croak
#         "$^E writing $self->{TEMP_FILE_NAME} for kid to read on fd $self->{KFD}";
#      _debug
#         "Win32 optimizer: wrote $bytes_written to temp file $self->{TEMP_FILE_NAME}"
#         if _debugging_data;
#
#      $self->_reset_temp_file_pointer;
#
#   }
#
#
#   _debug "Win32 optimizer: kid to read $self->{KFD} from temp file on $self->{TFD}"
#      if _debugging_details;
#}
#
#
#sub _init_recv_through_temp_file {
#   my IPC::Run::Win32IO $self = shift;
#
#   $self->_create_temp_file;
#}
#
#
#sub _recv_through_temp_file {
#   my IPC::Run::Win32IO $self = shift;
#
#   return undef unless defined $self->{TEMP_FILE_HANDLE};
#
#   push @{$self->{FILTERS}}, sub {
#      my ( undef, $out_ref ) = @_;
#
#      return undef unless defined $self->{TEMP_FILE_HANDLE};
#
#      my $r;
#      my $s;
#      ReadFile(
#	 $self->{TEMP_FILE_HANDLE},
#	 $s,
#	 999_999,  
#	 $r,
#	 []
#      ) or croak "$^E reading from $self->{TEMP_FILE_NAME}";
#
#      _debug "ReadFile( $self->{TFD} ) = $r chars '$s'" if _debugging_data;
#
#      return undef unless $r;
#
#      $s =~ s/\r\n/\n/g unless $self->binmode;
#
#      my $pos = pos $$out_ref;
#      $$out_ref .= $s;
#      pos( $out_ref ) = $pos;
#      return 1;
#   };
#
#   my ( $harness ) = @_;
#
#   $self->_reset_temp_file_pointer;
#
#   1 while $self->_do_filters( $harness );
#
#   pop @{$self->{FILTERS}};
#
#   IPC::Run::_close( $self->{TFD} );
#}
#
#
#sub poll {
#   my IPC::Run::Win32IO $self = shift;
#
#   return if $self->{SEND_THROUGH_TEMP_FILE} || $self->{RECV_THROUGH_TEMP_FILE};
#
#   return $self->SUPER::poll( @_ );
#}
#
#
#
#sub _spawn_pumper {
#   my ( $stdin, $stdout, $debug_fd, $binmode, $child_label, @opts ) = @_;
#   my ( $stdin_fd, $stdout_fd ) = ( fileno $stdin, fileno $stdout );
#
#   _debug "pumper stdin = ", $stdin_fd if _debugging_details;
#   _debug "pumper stdout = ", $stdout_fd if _debugging_details;
#   _inherit $stdin_fd, $stdout_fd, $debug_fd;
#   my @I_options = map qq{"-I$_"}, @INC;
#
#   my $cmd_line = join( " ",
#      qq{"$^X"},
#      @I_options,
#      qw(-MIPC::Run::Win32Pump -e 1 ),
#      FdGetOsFHandle( $stdin_fd ), 
#      FdGetOsFHandle( $stdout_fd ), 
#      FdGetOsFHandle( $debug_fd ), 
#      $binmode ? 1 : 0,
#      $$, $^T, _debugging_level, qq{"$child_label"},
#      @opts
#   );
#
#
#   _debug "pump cmd line: ", $cmd_line if _debugging_details;
#
#   my $process;
#   Win32::Process::Create( 
#      $process,
#      $^X,
#      $cmd_line,
#      1,  
#      NORMAL_PRIORITY_CLASS,
#      ".",
#   ) or croak "$!: Win32::Process::Create()";
#
#
#   close $stdin  or croak "$! closing pumper's stdin in parent";
#   close $stdout or croak "$! closing pumper's stdout in parent";
#
#
#   _debug "_spawn_pumper pid = ", $process->GetProcessID 
#      if _debugging_data;
#}
#
#
#my $next_port = 2048;
#my $loopback  = inet_aton "127.0.0.1";
#my $tcp_proto = getprotobyname('tcp');
#croak "$!: getprotobyname('tcp')" unless defined $tcp_proto;
#
#sub _socket {
#   my ( $server ) = @_;
#   $server ||= gensym;
#   my $client = gensym;
#
#   my $listener = gensym;
#   socket $listener, PF_INET, SOCK_STREAM, $tcp_proto
#      or croak "$!: socket()";
#   setsockopt $listener, SOL_SOCKET, SO_REUSEADDR, pack("l", 0)
#      or croak "$!: setsockopt()";
#
#   my $port;
#   my @errors;
#PORT_FINDER_LOOP:
#   {
#      $port = $next_port;
#      $next_port = 2048 if ++$next_port > 65_535; 
#      unless ( bind $listener, sockaddr_in( $port, $loopback ) ) {
#	 push @errors, "$! on port $port";
#	 croak join "\n", @errors if @errors > 10;
#         goto PORT_FINDER_LOOP;
#      }
#   }
#
#   _debug "win32 port = $port" if _debugging_details;
#
#   listen $listener, my $queue_size = 1
#      or croak "$!: listen()";
#
#   {
#      socket $client, PF_INET, SOCK_STREAM, $tcp_proto
#         or croak "$!: socket()";
#
#      my $paddr = sockaddr_in($port, $loopback );
#
#      connect $client, $paddr
#         or croak "$!: connect()";
#    
#      croak "$!: accept" unless defined $paddr;
#
#      setsockopt $client, IPPROTO_TCP, TCP_NODELAY, pack("l", 0)
#	 or croak "$!: setsockopt()";
#   }
#
#   {
#      _debug "accept()ing on port $port" if _debugging_details;
#      my $paddr = accept( $server, $listener );
#      croak "$!: accept()" unless defined $paddr;
#   }
#
#   _debug
#      "win32 _socket = ( ", fileno $server, ", ", fileno $client, " ) on port $port" 
#      if _debugging_details;
#   return ( $server, $client );
#}
#
#
#sub _open_socket_pipe {
#   my IPC::Run::Win32IO $self = shift;
#   my ( $debug_fd, $parent_handle ) = @_;
#
#   my $is_send_to_child = $self->dir eq "<";
#
#   $self->{CHILD_HANDLE}     = gensym;
#   $self->{PUMP_PIPE_HANDLE} = gensym;
#
#   ( 
#      $self->{PARENT_HANDLE},
#      $self->{PUMP_SOCKET_HANDLE}
#   ) = _socket $parent_handle;
#
#   binmode $self->{PARENT_HANDLE}      or die $!;
#   binmode $self->{PUMP_SOCKET_HANDLE} or die $!;
#
#_debug "PUMP_SOCKET_HANDLE = ", fileno $self->{PUMP_SOCKET_HANDLE}
#   if _debugging_details;
#
#   if ( $is_send_to_child ) {
#      pipe $self->{CHILD_HANDLE}, $self->{PUMP_PIPE_HANDLE}
#         or croak "$! opening child pipe";
#_debug "CHILD_HANDLE = ", fileno $self->{CHILD_HANDLE}
#   if _debugging_details;
#_debug "PUMP_PIPE_HANDLE = ", fileno $self->{PUMP_PIPE_HANDLE}
#   if _debugging_details;
#   }
#   else {
#      pipe $self->{PUMP_PIPE_HANDLE}, $self->{CHILD_HANDLE}
#         or croak "$! opening child pipe";
#_debug "CHILD_HANDLE = ", fileno $self->{CHILD_HANDLE}
#   if _debugging_details;
#_debug "PUMP_PIPE_HANDLE = ", fileno $self->{PUMP_PIPE_HANDLE}
#   if _debugging_details;
#   }
#
#   binmode $self->{CHILD_HANDLE};
#   binmode $self->{PUMP_PIPE_HANDLE};
#
#   _dont_inherit $self->{PARENT_HANDLE};
#
#   _dont_inherit $self->{PUMP_SOCKET_HANDLE};
#   _dont_inherit $self->{PUMP_PIPE_HANDLE};
#   _dont_inherit $self->{CHILD_HANDLE};
#
#   my ( $parent_fd, $child_fd ) = (
#      fileno $self->{PARENT_HANDLE},
#      fileno $self->{CHILD_HANDLE}
#   );
#
#   _debug "binmode on" if _debugging_data && $self->binmode;
#   _spawn_pumper(
#      $is_send_to_child
#	 ? ( $self->{PUMP_SOCKET_HANDLE}, $self->{PUMP_PIPE_HANDLE} )
#	 : ( $self->{PUMP_PIPE_HANDLE}, $self->{PUMP_SOCKET_HANDLE} ),
#      $debug_fd,
#      $self->binmode,
#      $child_fd . $self->dir . "pump" . $self->dir . $parent_fd,
#   );
#
#{
#my $foo;
#confess "PARENT_HANDLE no longer open"
#   unless POSIX::read( $parent_fd, $foo, 0 );
#}
#
#   _debug "win32_fake_pipe = ( $parent_fd, $child_fd )"
#      if _debugging_details;
#
#   $self->{FD}  = $parent_fd;
#   $self->{TFD} = $child_fd;
#}
#
#sub _do_open {
#   my IPC::Run::Win32IO $self = shift;
#
#   if ( $self->{SEND_THROUGH_TEMP_FILE} ) {
#      return $self->_send_through_temp_file( @_ );
#   }
#   elsif ( $self->{RECV_THROUGH_TEMP_FILE} ) {
#      return $self->_init_recv_through_temp_file( @_ );
#   }
#   else {
#      return $self->_open_socket_pipe( @_ );
#   }
#}
#
#1;
#
### IPC/Run/Win32Pump.pm ###
#package IPC::Run::Win32Pump;
#
#
#use strict;
#use vars qw{$VERSION};
#BEGIN {
#	$VERSION = '0.90';
#}
#
#use Win32API::File qw(
#   OsFHandleOpen
#);
#
#
#my ( $stdin_fh, $stdout_fh, $debug_fh, $binmode, $parent_pid, $parent_start_time, $debug, $child_label );
#BEGIN {
#   ( $stdin_fh, $stdout_fh, $debug_fh, $binmode, $parent_pid, $parent_start_time, $debug, $child_label ) = @ARGV;
#   if ( $debug ) {
#      eval "use IPC::Run::Debug qw( :default _debug_init ); 1;"
#	 or die $@;
#   }
#   else {
#      eval <<STUBS_END or die $@;
#	 sub _debug {}
#	 sub _debug_init {}
#	 sub _debugging() { 0 }
#	 sub _debugging_data() { 0 }
#	 sub _debugging_details() { 0 }
#	 sub _debugging_gory_details() { 0 }
#	 1;
#STUBS_END
#   }
#}
#
#if ( $debug ) {       
#close STDERR;       
#OsFHandleOpen( \*STDERR, $debug_fh, "w" )       
# or print "$! opening STDERR as Win32 handle $debug_fh in pumper $$";       
#}       
#close STDIN;       
#OsFHandleOpen( \*STDIN, $stdin_fh, "r" )       
#or die "$! opening STDIN as Win32 handle $stdin_fh in pumper $$";       
#close STDOUT;       
#OsFHandleOpen( \*STDOUT, $stdout_fh, "w" )       
#or die "$! opening STDOUT as Win32 handle $stdout_fh in pumper $$";       
#
#binmode STDIN;
#binmode STDOUT;
#$| = 1;
#select STDERR; $| = 1; select STDOUT;
#
#$child_label ||= "pump";
#_debug_init(
#$parent_pid,
#$parent_start_time,
#$debug,
#fileno STDERR,
#$child_label,
#);
#
#_debug "Entered" if _debugging_details;
#
#$| = 1;
#my $buf;
#my $total_count = 0;
#while (1) {
#my $count = sysread STDIN, $buf, 10_000;
#last unless $count;
#if ( _debugging_gory_details ) {
# my $msg = "'$buf'";
# substr( $msg, 100, -1 ) = '...' if length $msg > 100;
# $msg =~ s/\n/\\n/g;
# $msg =~ s/\r/\\r/g;
# $msg =~ s/\t/\\t/g;
# $msg =~ s/([\000-\037\177-\277])/sprintf "\0x%02x", ord $1/eg;
# _debug sprintf( "%5d chars revc: ", $count ), $msg;
#}
#$total_count += $count;
#$buf =~ s/\r//g unless $binmode;
#if ( _debugging_gory_details ) {
# my $msg = "'$buf'";
# substr( $msg, 100, -1 ) = '...' if length $msg > 100;
# $msg =~ s/\n/\\n/g;
# $msg =~ s/\r/\\r/g;
# $msg =~ s/\t/\\t/g;
# $msg =~ s/([\000-\037\177-\277])/sprintf "\0x%02x", ord $1/eg;
# _debug sprintf( "%5d chars sent: ", $count ), $msg;
#}
#print $buf;
#}
#
#_debug "Exiting, transferred $total_count chars" if _debugging_details;
#
#close STDOUT;
#close STDERR;
#
#1;
#
### IPC/System/Options.pm ###
#package IPC::System::Options;
#
#our $DATE = '2016-10-11'; 
#our $VERSION = '0.29'; 
#
#use strict;
#use warnings;
#
#use Proc::ChildError qw(explain_child_error);
#use String::ShellQuote;
#
#my $log;
#our %Global_Opts;
#
#sub import {
#    my $self = shift;
#
#    my $caller = caller();
#    my $i = 0;
#    while ($i < @_) {
#        if ($_[$i] =~ /\A(system|readpipe|backtick|run|import)\z/) {
#            no strict 'refs';
#            *{"$caller\::$_[$i]"} = \&{"$self\::" . $_[$i]};
#        } elsif ($_[$i] =~ /\A-(.+)/) {
#            die "$_[$i] requires an argument" unless $i < @_-1;
#            $Global_Opts{$1} = $_[$i+1];
#            $i++;
#        } else {
#            die "$_[$i] is not exported by ".__PACKAGE__;
#        }
#        $i++;
#    }
#}
#
#sub _quote {
#    if (@_ == 1) {
#        return $_[0];
#    }
#
#    if ($^O eq 'MSWin32') {
#        require Win32::ShellQuote;
#        return Win32::ShellQuote::quote_system_string(@_);
#    } else {
#        return shell_quote(@_);
#    }
#}
#
#sub _system_or_readpipe_or_run {
#    my $which = shift;
#    my $opts = ref($_[0]) eq 'HASH' ? shift : {};
#    for (keys %Global_Opts) {
#        $opts->{$_} = $Global_Opts{$_} if !defined($opts->{$_});
#    }
#    my @args = @_;
#
#    for (keys %$opts) {
#        die "Unknown option '$_'"
#            unless /\A(
#                        capture_stdout|capture_stderr|
#                        chdir|dies?|dry_run|env|lang|log||max_log_output|shell|
#                        stdin # XXX: only for run()
#                    )\z/x;
#    }
#
#    my $opt_die = $opts->{die} || $opts->{dies};
#
#    my $exit_code;
#    my $os_error = "";
#    my $extra_error;
#
#    $log ||= do { require Log::Any::IfLOG; Log::Any::IfLOG->get_logger } if $opts->{log};
#
#    my $cwd;
#    if ($opts->{chdir}) {
#        require Cwd;
#        $cwd = Cwd::getcwd();
#        if (!defined $cwd) { 
#            $log->error("Can't getcwd: $!") if $log;
#            $exit_code = -1;
#            $os_error = $!;
#            $extra_error = "Can't getcwd";
#            goto CHECK_RESULT;
#        }
#        unless (chdir $opts->{chdir}) {
#            $log->error("Can't chdir to '$opts->{chdir}': $!") if $log;
#            $exit_code = -1;
#            $os_error = $!;
#            $extra_error = "Can't chdir";
#            goto CHECK_RESULT;
#        }
#    }
#
#    my %save_env;
#    my %set_env;
#    if ($opts->{lang}) {
#        $set_env{LC_ALL}   = $opts->{lang};
#        $set_env{LANGUAGE} = $opts->{lang};
#        $set_env{LANG}     = $opts->{lang};
#    }
#    if ($opts->{env}) {
#        $set_env{$_} = $opts->{env}{$_} for keys %{ $opts->{env} };
#    }
#    if (%set_env) {
#        for (keys %set_env) {
#            $save_env{$_} = $ENV{$_};
#            $ENV{$_} = $set_env{$_};
#        }
#    }
#
#    my $wa;
#    my $res;
#
#    my $code_capture = sub {
#        my $doit = shift;
#
#        if ($opts->{capture_stdout} && $opts->{capture_stderr}) {
#            require Capture::Tiny;
#            (${ $opts->{capture_stdout} }, ${ $opts->{capture_stderr} }) =
#                &Capture::Tiny::capture($doit);
#        } elsif ($opts->{capture_stdout}) {
#            require Capture::Tiny;
#            ${ $opts->{capture_stdout} } =
#                &Capture::Tiny::capture_stdout($doit);
#        } elsif ($opts->{capture_stderr}) {
#            require Capture::Tiny;
#            ${ $opts->{capture_stderr} } =
#                &Capture::Tiny::capture_stderr($doit);
#        } else {
#            $doit->();
#        }
#    };
#
#    if ($which eq 'system') {
#
#        if ($opts->{log} || $opts->{dry_run}) {
#            if ($opts->{log}) {
#                my $meth;
#                my $label = "";
#                if ($opts->{dry_run}) {
#                    $label = "[DRY RUN] ";
#                    $meth = "infof";
#                } else {
#                    $meth = "tracef";
#                }
#                $log->$meth("%ssystem(%s), env=%s", $label, \@args, \%set_env);
#            } else {
#                warn "[DRY RUN] system(".join(", ", @args).")\n";
#            }
#            if ($opts->{dry_run}) {
#                $exit_code = 0;
#                $res = "";
#                goto CHECK_RESULT;
#            }
#        }
#
#        my $doit = sub {
#            if ($opts->{shell}) {
#                $res = system _quote(@args);
#            } elsif (defined $opts->{shell}) {
#                $res = system {$args[0]} @args;
#            } else {
#                $res = system @args;
#            }
#            $exit_code = $?;
#            $os_error = $!;
#        };
#        $code_capture->($doit);
#
#    } elsif ($which eq 'readpipe') {
#
#        $wa = wantarray;
#        my $cmd = _quote(@args);
#
#        if ($opts->{log} || $opts->{dry_run}) {
#            if ($opts->{log}) {
#                my $meth;
#                my $label = "";
#                if ($opts->{dry_run}) {
#                    $label = "[DRY RUN] ";
#                    $meth = "infof";
#                } else {
#                    $meth = "tracef";
#                }
#                $log->$meth("%sreadpipe(%s), env=%s", $label, $cmd, \%set_env);
#            } else {
#                warn "[DRY RUN] readpipe($cmd)\n";
#            }
#            if ($opts->{dry_run}) {
#                $exit_code = 0;
#                $res = "";
#                goto CHECK_RESULT;
#            }
#        }
#
#        my $doit = sub {
#            if ($wa) {
#                $res = [`$cmd`];
#            } else {
#                $res = `$cmd`;
#            }
#            $exit_code = $?;
#            $os_error = $!;
#        };
#        $code_capture->($doit);
#
#        if ($opts->{log}) {
#            my $res_show;
#            if (defined $opts->{max_log_output}) {
#                $res_show = '';
#                if ($wa) {
#                    for (@$res) {
#                        if (length($res_show) + length($_) >=
#                                $opts->{max_log_output}) {
#                            $res_show .= substr(
#                                $_,0,$opts->{max_log_output}-length($res_show));
#                            last;
#                        } else {
#                            $res_show .= $_;
#                        }
#                    }
#                } else {
#                    if (length($res) > $opts->{max_log_output}) {
#                        $res_show = substr($res, 0, $opts->{max_log_output});
#                    }
#                }
#            }
#            $log->tracef("result of readpipe(): %s (%d bytes)",
#                         defined($res_show) ? $res_show : $res,
#                         defined($res_show) ?
#                             $opts->{max_log_output} : length($res))
#                unless $exit_code;
#        }
#
#    } else {
#
#        if ($opts->{log} || $opts->{dry_run}) {
#            if ($opts->{log}) {
#                my $meth;
#                my $label = "";
#                if ($opts->{dry_run}) {
#                    $label = "[DRY RUN] ";
#                    $meth = "infof";
#                } else {
#                    $meth = "tracef";
#                }
#                $log->$meth("%srun(%s), env=%s", $label,
#                            join(", ", @args), \%set_env);
#            } else {
#                warn "[DRY RUN] run(".join(", ", @args).")\n";
#            }
#            if ($opts->{dry_run}) {
#                $exit_code = 0;
#                $res = "";
#                goto CHECK_RESULT;
#            }
#        }
#
#        require IPC::Run;
#        $res = IPC::Run::run(
#            \@args,
#            defined($opts->{stdin}) ? \$opts->{stdin} : \*STDIN,
#            sub {
#                if ($opts->{capture_stdout}) {
#                    ${$opts->{capture_stdout}} .= $_[0];
#                } else {
#                    print $_[0];
#                }
#            }, 
#            sub {
#                if ($opts->{capture_stderr}) {
#                    ${$opts->{capture_stderr}} .= $_[0];
#                } else {
#                    print STDERR $_[0];
#                }
#            }, 
#        );
#        $exit_code = $?;
#        $os_error = $!;
#
#    } 
#
#    if (%save_env) {
#        for (keys %save_env) {
#            if (defined $save_env{$_}) {
#                $ENV{$_} = $save_env{$_};
#            } else {
#                undef $ENV{$_};
#            }
#        }
#    }
#
#    if ($cwd) {
#        unless (chdir $cwd) {
#            $log->error("Can't chdir back to '$cwd': $!") if $log;
#            $exit_code ||= -1;
#            $os_error = $!;
#            $extra_error = "Can't chdir back";
#            goto CHECK_RESULT;
#        }
#    }
#
#  CHECK_RESULT:
#    if ($exit_code) {
#        if ($opts->{log} || $opt_die) {
#            my $msg = sprintf(
#                "%s(%s) failed: %s (%s)%s%s",
#                $which,
#                join(" ", @args),
#                defined $extra_error ? "" : $exit_code,
#                defined $extra_error ? "$extra_error: $os_error" : explain_child_error($exit_code, $os_error),
#                (ref($opts->{capture_stdout}) ?
#                     ", captured stdout: <<" .
#                     (defined ${$opts->{capture_stdout}} ? ${$opts->{capture_stdout}} : ''). ">>" : ""),
#                (ref($opts->{capture_stderr}) ?
#                     ", captured stderr: <<" .
#                     (defined ${$opts->{capture_stderr}} ? ${$opts->{capture_stderr}} : ''). ">>" : ""),
#            );
#            $log->error($msg) if $opts->{log};
#            die $msg if $opt_die;
#        }
#    }
#
#    $? = $exit_code;
#
#    return $wa && $which ne 'run' ? @$res : $res;
#}
#
#sub system {
#    _system_or_readpipe_or_run('system', @_);
#}
#
#sub backtick {
#    _system_or_readpipe_or_run('readpipe', @_);
#}
#
#sub readpipe {
#    _system_or_readpipe_or_run('readpipe', @_);
#}
#
#sub run {
#    _system_or_readpipe_or_run('run', @_);
#}
#
#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.12'; 
#
#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;
#    if ($opts->{sort_by}) {
#        @k = sort { $opts->{sort_by}->() } keys %$value;
#    } else {
#        @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/MaybeXS.pm ###
#package JSON::MaybeXS;
#
#use strict;
#use warnings FATAL => 'all';
#use base qw(Exporter);
#
#our $VERSION = '1.003005';
#$VERSION = eval $VERSION;
#
#sub _choose_json_module {
#    return 'Cpanel::JSON::XS' if $INC{'Cpanel/JSON/XS.pm'};
#    return 'JSON::XS'         if $INC{'JSON/XS.pm'};
#
#    my @err;
#
#    return 'Cpanel::JSON::XS' if eval { require Cpanel::JSON::XS; 1; };
#    push @err, "Error loading Cpanel::JSON::XS: $@";
#
#    return 'JSON::XS' if eval { require JSON::XS; 1; };
#    push @err, "Error loading JSON::XS: $@";
#
#    return 'JSON::PP' if eval { require JSON::PP; 1 };
#    push @err, "Error loading JSON::PP: $@";
#
#    die join( "\n", "Couldn't load a JSON module:", @err );
#
#}
#
#BEGIN {
#    our $JSON_Class = _choose_json_module();
#    $JSON_Class->import(qw(encode_json decode_json));
#}
#
#our @EXPORT = qw(encode_json decode_json JSON);
#my @EXPORT_ALL = qw(is_bool);
#our @EXPORT_OK = qw(is_bool to_json from_json);
#our %EXPORT_TAGS = ( all => [ @EXPORT, @EXPORT_ALL ],
#                     legacy => [ @EXPORT, @EXPORT_OK ],
#                   );
#
#sub JSON () { our $JSON_Class }
#
#sub new {
#  shift;
#  my %args = @_ == 1 ? %{$_[0]} : @_;
#  my $new = (our $JSON_Class)->new;
#  $new->$_($args{$_}) for keys %args;
#  return $new;
#}
#
#use Scalar::Util ();
#
#sub is_bool {
#  die 'is_bool is not a method' if $_[1];
#
#  Scalar::Util::blessed($_[0])
#    and ($_[0]->isa('JSON::XS::Boolean')
#      or $_[0]->isa('Cpanel::JSON::XS::Boolean')
#      or $_[0]->isa('JSON::PP::Boolean'));
#}
#
#use Carp ();
#
#sub from_json ($@) {
#    if ( ref($_[0]) =~ /^JSON/ or $_[0] =~ /^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 to_json ($@) {
#    if (
#        ref($_[0]) =~ /^JSON/
#        or (@_ > 2 and $_[0] =~ /^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]);
#}
#
#1;
#
### 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.15";
#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.15";
#
#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.15";
#
#
#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/MediaTypes.pm ###
#package LWP::MediaTypes;
#
#require Exporter;
#@ISA = qw(Exporter);
#@EXPORT = qw(guess_media_type media_suffix);
#@EXPORT_OK = qw(add_type add_encoding read_media_types);
#$VERSION = "6.02";
#
#use strict;
#
#
#my %suffixType = (
#    'txt'   => 'text/plain',
#    'html'  => 'text/html',
#    'gif'   => 'image/gif',
#    'jpg'   => 'image/jpeg',
#    'xml'   => 'text/xml',
#);
#
#my %suffixExt = (
#    'text/plain' => 'txt',
#    'text/html'  => 'html',
#    'image/gif'  => 'gif',
#    'image/jpeg' => 'jpg',
#    'text/xml'   => 'xml',
#);
#
#my %suffixEncoding = (
#    'Z'   => 'compress',
#    'gz'  => 'gzip',
#    'hqx' => 'x-hqx',
#    'uu'  => 'x-uuencode',
#    'z'   => 'x-pack',
#    'bz2' => 'x-bzip2',
#);
#
#read_media_types();
#
#
#
#sub guess_media_type
#{
#    my($file, $header) = @_;
#    return undef unless defined $file;
#
#    my $fullname;
#    if (ref($file)) {
#	$file = $file->path;
#    }
#    else {
#	$fullname = $file;  
#    }
#
#    my @encoding = ();
#    my $ct = undef;
#    for (file_exts($file)) {
#	if (exists $suffixEncoding{$_}) {
#	    unshift(@encoding, $suffixEncoding{$_});
#	    next;
#	}
#	if (exists $suffixEncoding{lc $_}) {
#	    unshift(@encoding, $suffixEncoding{lc $_});
#	    next;
#	}
#
#	if (exists $suffixType{$_}) {
#	    $ct = $suffixType{$_};
#	    last;
#	}
#	if (exists $suffixType{lc $_}) {
#	    $ct = $suffixType{lc $_};
#	    last;
#	}
#
#	last;
#    }
#    unless (defined $ct) {
#	if (defined $fullname) {
#	    $ct = (-T $fullname) ? "text/plain" : "application/octet-stream";
#	}
#	else {
#	    $ct = "application/octet-stream";
#	}
#    }
#
#    if ($header) {
#	$header->header('Content-Type' => $ct);
#	$header->header('Content-Encoding' => \@encoding) if @encoding;
#    }
#
#    wantarray ? ($ct, @encoding) : $ct;
#}
#
#
#sub media_suffix {
#    if (!wantarray && @_ == 1 && $_[0] !~ /\*/) {
#	return $suffixExt{lc $_[0]};
#    }
#    my(@type) = @_;
#    my(@suffix, $ext, $type);
#    foreach (@type) {
#	if (s/\*/.*/) {
#	    while(($ext,$type) = each(%suffixType)) {
#		push(@suffix, $ext) if $type =~ /^$_$/i;
#	    }
#	}
#	else {
#	    my $ltype = lc $_;
#	    while(($ext,$type) = each(%suffixType)) {
#		push(@suffix, $ext) if lc $type eq $ltype;
#	    }
#	}
#    }
#    wantarray ? @suffix : $suffix[0];
#}
#
#
#sub file_exts 
#{
#    require File::Basename;
#    my @parts = reverse split(/\./, File::Basename::basename($_[0]));
#    pop(@parts);        
#    @parts;
#}
#
#
#sub add_type 
#{
#    my($type, @exts) = @_;
#    for my $ext (@exts) {
#	$ext =~ s/^\.//;
#	$suffixType{$ext} = $type;
#    }
#    $suffixExt{lc $type} = $exts[0] if @exts;
#}
#
#
#sub add_encoding
#{
#    my($type, @exts) = @_;
#    for my $ext (@exts) {
#	$ext =~ s/^\.//;
#	$suffixEncoding{$ext} = $type;
#    }
#}
#
#
#sub read_media_types 
#{
#    my(@files) = @_;
#
#    local($/, $_) = ("\n", undef);  
#
#    my @priv_files = ();
#    push(@priv_files, "$ENV{HOME}/.media.types", "$ENV{HOME}/.mime.types")
#	if defined $ENV{HOME};  
#
#    my $typefile;
#    unless (@files) {
#	@files = map {"$_/LWP/media.types"} @INC;
#	push @files, @priv_files;
#    }
#    for $typefile (@files) {
#	local(*TYPE);
#	open(TYPE, $typefile) || next;
#	while (<TYPE>) {
#	    next if /^\s*#/; 
#	    next if /^\s*$/; 
#	    s/#.*//;         
#	    my($type, @exts) = split(' ', $_);
#	    add_type($type, @exts);
#	}
#	close(TYPE);
#    }
#}
#
#1;
#
#
#__END__
#
### 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.15";
#
#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/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.15";
#
#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.15";
#
#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.15";
#
#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;
#use warnings;
#use strict;
#require Exporter;
#our @ISA = qw(Exporter);
#our @EXPORT_OK = qw/to_singular is_plural/;
#our $VERSION = '0.18';
#
#
#
#
#my %irregular = (qw/
#    analyses analysis
#    brethren brother
#    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
#    oxen ox
#    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/
#                      deer
#                      ides
#                      fish
#                      means
#                      offspring
#                      series
#                      sheep
#                      species
#                  /;
#
#@plural{@no_change} = @no_change;
#
#
#
#
#my @not_plural = (qw/
#Aries
#Charles
#Gonzales 
#Hades 
#Hercules 
#Hermes 
#Holmes 
#Hughes 
#Ives 
#Jacques 
#James 
#Keyes 
#Mercedes 
#Naples 
#Oates 
#Raines 
#Texas
#athletics
#bogus
#bus
#cactus
#cannabis
#caries
#chaos
#citrus
#clothes
#corps
#corpus
#devious
#dias
#facies
#famous
#hippopotamus
#homunculus
#iris
#lens
#mathematics
#metaphysics
#metropolis
#mews
#minus
#miscellaneous
#molasses
#mrs
#narcissus
#news
#octopus
#ourselves
#papyrus
#perhaps
#physics
#platypus
#plus
#previous
#pus
#rabies
#scabies
#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
#hoes
#horseshoes
#oboes
#shoes
#snowshoes
#throes
#toes
#/);
#
#my %oes;
#
#@oes{@oes} = (1) x @oes;
#
#
#
#
#
#
#
#my @ies = (qw/
#Aussies
#Valkryies
#aunties
#bogies
#brownies
#calories
#charlies
#coolies
#coteries
#curies
#cuties
#dies
#genies
#goalies
#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$/;
#
#
#my @i_to_us = (qw/
#abaci
#abaculi
#acanthi
#acini
#alumni
#anthocauli
#bacilli
#baetuli
#cacti
#calculi
#calli
#catheti
#emboli
#emeriti
#esophagi
#foci
#foeti
#fumuli
#fungi
#gonococci
#hippopotami
#homunculi
#incubi
#loci
#macrofungi
#macronuclei
#naevi
#nuclei
#obeli
#octopi
#oeconomi
#oesophagi
#panni
#periœci
#phocomeli
#phoeti
#platypi
#polypi
#precunei
#radii
#rhombi
#sarcophagi
#solidi
#stimuli
#succubi
#syllabi
#thesauri
#thrombi
#tori
#trophi
#uteri
#viri
#virii
#xiphopagi
#zygomatici
#/);
#
#my %i_to_us;
#@i_to_us{@i_to_us} = (1) x @i_to_us;
#
#my @i_to_o = (qw/
#    alveoli
#    ghetti
#    manifesti
#    ostinati
#    pianissimi
#    scenarii
#    stiletti
#    torsi
#/);
#
#my %i_to_o;
#@i_to_o{@i_to_o} = (1) x @i_to_o;
#
#my %i_to_other = (
#    improvisatori => 'improvisatore',
#    rhinoceri => 'rhinoceros',
#    scaloppini => 'scaloppine'
#);
#
#
#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$//;
#            }
#        }
#        elsif ($word =~ /i$/) {
#            if ($i_to_us{$word}) {
#                $singular =~ s/i$/us/;
#            }
#            elsif ($i_to_o{$word}) {
#                $singular =~ s/i$/o/;
#            }
#            if ($i_to_other{$word}) {
#                $singular = $i_to_other{$word};
#            }
#        }
#
#    }
#    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.26';
#
#$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.26';
#
#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.042';
#
#use Log::Any::Manager;
#use Log::Any::Proxy::Null;
#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'} ) {
#        my @default_adapter_params = ();
#        if (ref $default eq 'ARRAY') {
#            ($default, @default_adapter_params) = @{ $default };
#        }
#        $class->_manager->set_default(
#            $category, $default, @default_adapter_params
#        );
#    }
#
#    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" if !$proxy_name && _manager->has_consumer;
#    return "Log::Any::Proxy::Null" if !$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.042';
#
#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.042';
#
#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.042';
#
#use Config;
#use Fcntl qw/:flock/;
#use IO::File;
#use Log::Any::Adapter::Util ();
#
#use Log::Any::Adapter::Base;
#our @ISA = 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};
#    my $binmode ||= ':utf8';
#    $binmode = ":$binmode" unless substr($binmode,0,1) eq ':';
#    open( $self->{fh}, ">>$binmode", $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.042';
#
#use Log::Any::Adapter::Base;
#our @ISA = 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 = '2016-10-04'; 
#our $VERSION = '0.13'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Log::Any;
#use Log::Any::Adapter::Util qw(make_method);
#use parent qw(Log::Any::Adapter::Base);
#
#my $CODE_RESET = "\e[0m"; 
#my $DEFAULT_COLORS = {alert=>"\e[31m",critical=>"\e[31m",debug=>"",emergency=>"\e[31m",error=>"\e[35m",info=>"\e[32m",notice=>"\e[32m",trace=>"\e[33m",warning=>"\e[1;34m"}; 
#
#my $Time0;
#
#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 _min_level {
#    my $self = shift;
#
#    return $ENV{LOG_LEVEL}
#        if $ENV{LOG_LEVEL} && defined $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};
#    $self->{default_level};
#}
#
#sub init {
#    my ($self) = @_;
#    $self->{default_level} //= 'warning';
#    $self->{stderr}    //= 1;
#    $self->{use_color} //= $ENV{COLOR} // (-t STDOUT);
#    if ($self->{colors}) {
#        require Term::ANSIColor;
#        my $orig = $self->{colors};
#        $self->{colors} = {
#            map {($_,($orig->{$_} ? Term::ANSIColor::color($orig->{$_}) : ''))}
#                keys %$orig
#            };
#    } else {
#        $self->{colors} = $DEFAULT_COLORS;
#    }
#    $self->{min_level} //= $self->_min_level;
#    if (!$self->{formatter}) {
#        if (($ENV{LOG_PREFIX} // '') eq 'elapsed') {
#            require Time::HiRes;
#            $Time0 //= Time::HiRes::time();
#        }
#        $self->{formatter} = sub {
#            my ($self, $msg) = @_;
#            my $env = $ENV{LOG_PREFIX} // '';
#            if ($env eq 'elapsed') {
#                my $time = Time::HiRes::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 = $self->{colors}{$method} . $msg . $CODE_RESET;
#            }
#
#            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.042';
#
#use Log::Any::Adapter::Util ();
#
#use Log::Any::Adapter::Base;
#our @ISA = 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.042';
#
#use Log::Any::Adapter::Util ();
#
#use Log::Any::Adapter::Base;
#our @ISA = 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.042';
#
#use Log::Any::Adapter::Util qw/dump_one_line/;
#use Test::Builder;
#
#use Log::Any::Adapter::Base;
#our @ISA = 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 ) = @_;
#
#    local $Test::Builder::Level = $Test::Builder::Level + 1;
#
#    $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" );
#        _diag_msgs();
#    }
#}
#
#sub category_contains_ok {
#    my ( $self, $category, $regex, $test_name ) = @_;
#
#    local $Test::Builder::Level = $Test::Builder::Level + 1;
#
#    $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" );
#        _diag_msgs();
#    }
#}
#
#sub does_not_contain_ok {
#    my ( $self, $regex, $test_name ) = @_;
#
#    local $Test::Builder::Level = $Test::Builder::Level + 1;
#
#    $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]->{message} );
#    }
#    else {
#        $tb->ok( 1, $test_name );
#    }
#}
#
#sub category_does_not_contain_ok {
#    my ( $self, $category, $regex, $test_name ) = @_;
#
#    local $Test::Builder::Level = $Test::Builder::Level + 1;
#
#    $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 ) = @_;
#
#    local $Test::Builder::Level = $Test::Builder::Level + 1;
#
#    $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" );
#        _diag_msgs();
#        $self->clear();
#    }
#}
#
#sub contains_only_ok {
#    my ( $self, $regex, $test_name ) = @_;
#
#    local $Test::Builder::Level = $Test::Builder::Level + 1;
#
#    $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 );
#        _diag_msgs();
#    }
#}
#
#sub _diag_msgs {
#    my $count = @msgs;
#    if ( ! $count ) {
#        $tb->diag("log contains no messages");
#    }
#    else {
#        $tb->diag("log contains $count message" . ( $count > 1 ? "s:" : ":"));
#        $tb->diag(dump_one_line($_)) for @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.042';
#
#use Exporter;
#our @ISA = 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) };
#}
#
#
#*dump_one_line = sub {
#    require Data::Dumper;
#
#    my $dumper = sub {
#        my ($value) = @_;
#
#        return Data::Dumper->new( [$value] )->Indent(0)->Sortkeys(1)->Quotekeys(0)
#        ->Terse(1)->Useqq(1)->Dump();
#    };
#
#    my $string = $dumper->(@_);
#    no warnings 'redefine';
#    *dump_one_line = $dumper;
#    return $string;
#};
#
#
#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, '<:utf8', $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 = '2016-03-16'; 
#our $VERSION = '0.53'; 
#
#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::MaybeXS;
#
#    my $def = pop @_;
#    for (@_) {
#        return JSON::MaybeXS::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 = '2016-06-16'; 
#our $VERSION = '0.08'; 
#
#our $DEBUG;
#our $ENABLE_LOG;
#
#my $log_singleton;
#sub __log_singleton {
#    if (!$log_singleton) { $log_singleton = Log::Any::IfLOG::DumbObj->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
#    Log::Any::IfLOG::DumbObj;
#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.042';
#
#sub new {
#    my $class = shift;
#    my $self  = {
#        entries         => [],
#        category_cache  => {},
#        default_adapter => {},
#    };
#    bless $self, $class;
#
#    return $self;
#}
#
#sub has_consumer {
#    my ( $self ) = @_;
#    return !!( @{ $self->{entries} } || keys %{ $self->{default_adapter} } );
#}
#
#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 ) = @_;
#    Log::Any::Proxy::Null->inflate_nulls;
#    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() } );
#    }
#
#    Log::Any::Proxy::Null->inflate_nulls;
#    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.042';
#
#use Log::Any::Adapter::Util ();
#
#sub _default_formatter {
#    my ( $cat, $lvl, $format, @params ) = @_;
#    return $format->() if ref($format) eq 'CODE';
#    my @new_params =
#      map {
#           !defined($_) ? '<undef>'
#          : ref($_)     ? Log::Any::Adapter::Util::dump_one_line($_)
#          : $_
#      } @params;
#    no warnings;
#    return sprintf( $format, @new_params );
#}
#
#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 );
#        if ( length $message ) {
#            $message = $self->{filter}->( $self->{category}, $numeric, $message )
#              if defined $self->{filter};
#            if ( defined $message and length $message ) {
#                $message = "$self->{prefix}$message"
#                  if defined $self->{prefix} && length $self->{prefix};
#                $self->{adapter}->$realname($message);
#            }
#        }
#        return $message if defined wantarray;
#    };
#    *{$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/Null.pm ###
#use 5.008001;
#use strict;
#use warnings;
#
#package Log::Any::Proxy::Null;
#
#our $VERSION = '1.042';
#
#use Log::Any::Adapter::Util ();
#use Log::Any::Proxy;
#our @ISA = qw/Log::Any::Proxy/;
#
#my @nulls;
#
#sub new {
#    my $obj = shift->SUPER::new( @_ );
#    push @nulls, $obj;
#    return $obj;
#}
#
#sub inflate_nulls {
#    bless shift( @nulls ), 'Log::Any::Proxy' while @nulls;
#}
#
#my %aliases = Log::Any::Adapter::Util::log_level_aliases();
#
#foreach my $name ( Log::Any::Adapter::Util::logging_methods(), keys(%aliases) )
#{
#    my $namef       = $name . "f";
#    my $super_name  = "SUPER::" . $name;
#    my $super_namef = "SUPER::" . $namef;
#    no strict 'refs';
#    *{$name} = sub {
#        return unless defined wantarray;
#        return shift->$super_name( @_ );
#    };
#    *{$namef} = sub {
#        return unless defined wantarray;
#        return shift->$super_namef( @_ );
#    };
#}
#
#1;
#
#__END__
#
### Log/Any/Proxy/Test.pm ###
#use 5.008001;
#use strict;
#use warnings;
#
#package Log::Any::Proxy::Test;
#
#our $VERSION = '1.042';
#
#use Log::Any::Proxy;
#our @ISA = 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.042';
#
#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.56';
#
#use base qw( Log::Dispatch::Base );
#
#use Log::Dispatch::Vars qw( %CanonicalLevelNames @OrderedLevels );
#use Module::Runtime qw( use_package_optimistically );
#use Params::Validate 1.03 qw(validate_with ARRAYREF CODEREF);
#use Carp ();
#
#BEGIN {
#    foreach my $l ( keys %CanonicalLevelNames ) {
#        my $sub = sub {
#            my $self = shift;
#            $self->log(
#                level   => $CanonicalLevelNames{$l},
#                message => @_ > 1 ? "@_" : $_[0],
#            );
#        };
#
#        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    = @_;
#
#    if ( exists $p{level} && $p{level} =~ /\A[0-7]\z/ ) {
#        $p{level} = $OrderedLevels[ $p{level} ];
#    }
#
#    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;
#
#    if ( !defined $level ) {
#        Carp::croak('Logging level was not provided');
#    }
#
#    return $CanonicalLevelNames{$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.56';
#
#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.56';
#
#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.56';
#
#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-12-16'; 
#our $VERSION = '0.14'; 
#
#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);
#        ($ext) = $ext =~ /(.+)/ if $ext; 
#        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.56';
#
#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.56';
#
#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.56';
#
#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 ( $?, $@, $SIG{__DIE__} );
#    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.56';
#
#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 ( $?, $@, $SIG{__DIE__} );
#    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.56';
#
#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.56';
#
#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}': $!";
#        delete $self->{fh};
#    }
#}
#
#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.56';
#
#use Fcntl qw(:DEFAULT :flock);
#
#sub log_message {
#    my $self = shift;
#    my %p    = @_;
#
#    if ( $self->{close} ) {
#        $self->_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}': $!";
#
#    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}': $!";
#    }
#
#    flock( $fh, LOCK_UN ) or die "Cannot unlock '$self->{filename}'";
#    if ( $self->{close} ) {
#        close $fh
#            or die "Cannot close '$self->{filename}': $!";
#        delete $self->{fh};
#    }
#}
#
#1;
#
#
#__END__
#
### Log/Dispatch/FileWriteRotate.pm ###
#package Log::Dispatch::FileWriteRotate;
#
#our $DATE = '2016-10-02'; 
#our $VERSION = '0.05'; 
#
#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.56';
#
#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.56';
#
#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.56';
#
#use Log::Dispatch;
#
#use base qw( Log::Dispatch::Base );
#
#use Log::Dispatch::Vars qw( %LevelNamesToNumbers @OrderedLevels );
#use Params::Validate qw(validate SCALAR ARRAYREF CODEREF BOOLEAN);
#Params::Validate::validation_options( allow_extra => 1 );
#
#use Carp ();
#
#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} );
#
#    local $!;
#    $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}   = \@OrderedLevels;
#    $self->{level_numbers} = \%LevelNamesToNumbers;
#
#    $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.56';
#
#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.56';
#
#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} ) {
#
#        unless ($threads_loaded) {
#            local ( $@, $SIG{__DIE__} );
#
#            eval 'use threads; use threads::shared';
#            $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};
#
#    local ( $@, $SIG{__DIE__} );
#    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/Dispatch/Vars.pm ###
#package Log::Dispatch::Vars;
#
#use strict;
#use warnings;
#
#our $VERSION = '2.56';
#
#use Exporter qw( import );
#
#our @EXPORT_OK = qw(
#    %CanonicalLevelNames
#    %LevelNamesToNumbers
#    @OrderedLevels
#);
#
#our %CanonicalLevelNames = (
#    (
#        map { $_ => $_ }
#            qw(
#            debug
#            info
#            notice
#            warning
#            error
#            critical
#            alert
#            emergency
#            )
#    ),
#    warn  => 'warning',
#    err   => 'error',
#    crit  => 'critical',
#    emerg => 'emergency',
#);
#
#our @OrderedLevels = qw(
#    debug
#    info
#    notice
#    warning
#    error
#    critical
#    alert
#    emergency
#);
#
#our %LevelNamesToNumbers = (
#    ( map { $OrderedLevels[$_] => $_ } 0 .. $#OrderedLevels ),
#    warn  => 3,
#    err   => 4,
#    crit  => 5,
#    emerg => 7
#);
#
#1;
#
#
#__END__
#
### Log/Log4perl.pm ###
#package Log::Log4perl;
#
#END { local($?); Log::Log4perl::Logger::cleanup(); }
#
#use 5.006;
#use strict;
#use warnings;
#
#use Carp;
#
#use Log::Log4perl::Util;
#use Log::Log4perl::Logger;
#use Log::Log4perl::Level;
#use Log::Log4perl::Config;
#use Log::Log4perl::Appender;
#
#our $VERSION = '1.47';
#
#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;
#            } else {
#                carp "All arguments to easy_init should be either "
#                   . "an integer log level or a hash reference.";
#            }
#        }
#    }
#
#    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 (sort 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" } 
#                sort keys %{$data->{filter}->{$filter_name}});
#        }
#        $filter->register();
#    }
#
#    for my $name (sort 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"
#                              } sort 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}} 
#                                     sort 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 ( sort 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(sort 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( sort 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 "%s";
#
#    } 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 $1 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 qw(_load_module _maybe_load_module _install_coderef);
#use Moo::Object ();
#BEGIN { our @ISA = qw(Moo::Object) }
#use Sub::Quote qw(quote_sub quoted_from_sub quotify sanitize_identifier);
#use Scalar::Util 'blessed';
#use Carp qw(croak);
#BEGIN { our @CARP_NOT = qw(Moo::_Utils) }
#use overload ();
#BEGIN {
#  *_CAN_WEAKEN_READONLY = (
#    "$]" < 5.008_003 or $ENV{MOO_TEST_PRE_583}
#  ) ? sub(){0} : sub(){1};
#  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') })
#  ;
#}
#BEGIN {
#  package
#    Method::Generate::Accessor::_Generated;
#  $Carp::Internal{+__PACKAGE__} = 1;
#}
#
#my $module_name_only = qr/\A$Module::Runtime::module_name_rx\z/;
#
#sub _die_overwrite
#{
#  my ($pkg, $method, $type) = @_;
#  croak "You cannot overwrite a locally defined method ($method) with "
#    . ( $type || 'an accessor' );
#}
#
#sub generate_method {
#  my ($self, $into, $name, $spec, $quote_opts) = @_;
#  $quote_opts = {
#    no_defer => 1,
#    package => 'Method::Generate::Accessor::_Generated',
#    %{ $quote_opts||{} },
#  };
#  $spec->{allow_overwrite}++ if $name =~ s/^\+//;
#  croak "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') {
#    croak "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;
#    croak "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 {
#      croak "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}"
#          => '    Carp::croak("'.$reader.' is a read-only accessor") if @_ > 1;'."\n"
#             .$self->_generate_get($name, $spec)
#          => delete $self->{captures}
#          => $quote_opts
#        ;
#    }
#  }
#  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}
#          => $quote_opts
#        ;
#    }
#  }
#  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}
#          => $quote_opts
#        ;
#    }
#  }
#  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"
#          => {}
#          => $quote_opts
#        ;
#    }
#  }
#  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"
#        => {}
#        => $quote_opts
#      ;
#  }
#  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)) {
#        require Moo::Role;
#        _load_module $hspec;
#        map [ $_ => $_ ], Moo::Role->methods_provided_by($hspec)
#      } else {
#        croak "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}
#          => $quote_opts
#        ;
#    }
#  }
#  if (my $asserter = $spec->{asserter}) {
#    _die_overwrite($into, $asserter, 'an asserter')
#      if !$spec->{allow_overwrite} && defined &{"${into}::${asserter}"};
#    local $self->{captures} = {};
#    $methods{$asserter} =
#      quote_sub "${into}::${asserter}"
#        => $self->_generate_asserter($name, $spec)
#        => delete $self->{captures}
#        => $quote_opts
#      ;
#  }
#  \%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) = @_;
#  my ($me, $source) = ('$_[0]', '$_[1]');
#  if ($self->is_simple_set($name, $spec)) {
#    return $self->_generate_simple_set($me, $name, $spec, $source);
#  }
#
#  my ($coerce, $trigger, $isa_check) = @{$spec}{qw(coerce trigger isa)};
#  if ($coerce) {
#    $source = $self->_generate_coerce($name, $source, $coerce);
#  }
#  if ($isa_check) {
#    'scalar do { my $value = '.$source.";\n"
#    .'  ('.$self->_generate_isa_check($name, '$value', $isa_check)."),\n"
#    .'  ('.$self->_generate_simple_set($me, $name, $spec, '$value')."),\n"
#    .($trigger
#      ? '('.$self->_generate_trigger($name, $me, '$value', $trigger)."),\n"
#      : '')
#    .'  ('.$self->_generate_simple_get($me, $name, $spec)."),\n"
#    ."}";
#  }
#  elsif ($trigger) {
#    my $set = $self->_generate_simple_set($me, $name, $spec, $source);
#    "scalar (\n"
#    . '  ('.$self->_generate_trigger($name, $me, "($set)", $trigger)."),\n"
#    . '  ('.$self->_generate_simple_get($me, $name, $spec)."),\n"
#    . ")";
#  }
#  else {
#    '('.$self->_generate_simple_set($me, $name, $spec, $source).')';
#  }
#}
#
#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), (my $_old_error = $@);'."\n"
#  ."  (eval {\n"
#  .'    ($@ = $_old_error),'."\n"
#  .'    ('
#  .($want_return ? '$_return ='."\n" : '')
#  .$code."),\n"
#  ."    1\n"
#  ."  } or\n"
#  .'    $_error = CORE::ref $@ ? $@ : '.$prefix.'.$@);'."\n"
#  .'  ($@ = $_old_error),'."\n"
#  .'  (defined $_error and CORE::die $_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_}.sanitize_identifier($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_}.sanitize_identifier($name);
#    $self->{captures}->{$cap_name} = \$sub;
#    "${cap_name}->(${values})";
#  }
#}
#
#sub _sanitize_name { sanitize_identifier($_[1]) }
#
#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) = @_;
#
#  my $has_default = $self->has_eager_default($name, $spec);
#  if (!($has_default || $test)) {
#    return '';
#  }
#  if ($has_default) {
#    my $get_default = $self->_generate_get_default($me, $name, $spec);
#    $source =
#      $test
#        ? "(\n  ${test}\n"
#            ."   ? ${source}\n   : "
#            .$get_default
#            .")"
#        : $get_default;
#  }
#  if ($spec->{coerce}) {
#    $source = $self->_generate_coerce(
#      $name, $source,
#      $spec->{coerce}, $init_arg
#    )
#  }
#  if ($spec->{isa}) {
#    $source = 'scalar do { my $value = '.$source.";\n"
#    .'  ('.$self->_generate_isa_check(
#        $name, '$value', $spec->{isa}, $init_arg
#      )."),\n"
#    ."  \$value\n"
#    ."}\n";
#  }
#  my $set = $self->_generate_simple_set($me, $name, $spec, $source);
#  my $trigger = $spec->{trigger} ? $self->_generate_trigger(
#    $name, $me, $self->_generate_simple_get($me, $name, $spec),
#    $spec->{trigger}
#  ) : undef;
#  if ($has_default) {
#    "($set)," . ($trigger ? "($test and $trigger)," : '')
#  }
#  else {
#    "($test and ($set)" . ($trigger ? ", ($trigger)" : '') . "),";
#  }
#}
#
#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 = _CAN_WEAKEN_READONLY
#      ? "do { Scalar::Util::weaken(${simple}); no warnings 'void'; $get }"
#      : <<"EOC"
#        ( 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"
#   ."  ".$self->_generate_simple_has('$_[0]', $name, $spec)."\n"
#   ."    or Carp::croak(\"Attempted to access '${name}' but it is not set\");\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))) {
#    croak "$invalid or code-convertible object";
#  }
#
#  unless (eval { \&$value }) {
#    croak "$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 ();
#BEGIN { our @ISA = qw(Moo::Object) }
#use Sub::Quote qw(quote_sub quotify);
#use Moo::_Utils qw(_getglob);
#use Moo::_mro;
#
#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},
#    )
#    => {}
#    => { no_defer => 1 }
#  ;
#}
#
#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)};
#  '    (('.$args.')[0]->{__no_BUILD__} or ('."\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 quotify);
#use Sub::Defer;
#use Moo::_Utils qw(_getstash _getglob);
#use Moo::_mro;
#use Scalar::Util qw(weaken);
#use Carp qw(croak);
#use Carp::Heavy ();
#BEGIN { our @CARP_NOT = qw(Sub::Defer) }
#BEGIN {
#  local $Moo::sification::disabled = 1;
#  require Moo;
#  Moo->import;
#}
#
#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/^\+//) {
#      croak "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}
#      )
#    ) {
#      croak "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;
#  my (undef, $from_file, $from_line) = caller(Carp::short_error_loc());
#  my $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';
#        croak "Expected parent constructor of $package to be"
#        . " $expected_new, but found $found_new: changing the inheritance"
#        . " chain (\@ISA) at runtime (after $from_file line $from_line) is unsupported";
#      }
#    }
#
#    my $constructor = $self->generate_method(
#      $package, 'new', $self->{attribute_specs}, { no_install => 1, no_defer => 1 }
#    );
#    $self->{inlined} = 1;
#    weaken($self->{constructor} = $constructor);
#    $constructor;
#  };
#  $self->{inlined} = 0;
#  weaken($self->{constructor} = $constructor);
#  $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 $constructor = $self->{constructor}
#    or croak "Unknown constructor for $package already exists";
#  croak "Constructor for $package has been replaced with an unknown sub"
#    if $constructor != $current;
#  croak "Constructor for $package has been inlined and cannot be updated"
#    if $self->{inlined};
#}
#
#sub generate_method {
#  my ($self, $into, $name, $spec, $quote_opts) = @_;
#  $quote_opts = {
#    %{$quote_opts||{}},
#    package => $into,
#  };
#  foreach my $no_init (grep !exists($spec->{$_}{init_arg}), keys %$spec) {
#    $spec->{$no_init}{init_arg} = $no_init;
#  }
#  local $self->{captures} = {};
#
#  my $into_buildargs = $into->can('BUILDARGS');
#
#  my $body
#    = '    my $invoker = CORE::shift();'."\n"
#    . '    my $class = CORE::ref($invoker) ? CORE::ref($invoker) : $invoker;'."\n"
#    . $self->_handle_subconstructor($into, $name)
#    . ( $into_buildargs && $into_buildargs != \&Moo::Object::BUILDARGS
#      ? $self->_generate_args_via_buildargs
#      : $self->_generate_args
#    )
#    . $self->_check_required($spec)
#    . '    my $new = '.$self->construction_string.";\n"
#    . $self->_assign_new($spec)
#    . ( $into->can('BUILD')
#      ? $self->buildall_generator->buildall_body_for( $into, '$new', '$args' )
#      : ''
#    )
#    . '    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{    Carp::croak("BUILDARGS did not return a hashref") unless CORE::ref($args) eq 'HASH';}
#  ."\n";
#}
#
#sub _generate_args {
#  my ($self) = @_;
#  return <<'_EOA';
#    my $args = scalar @_ == 1
#      ? CORE::ref $_[0] eq 'HASH'
#        ? { %{ $_[0] } }
#        : Carp::croak("Single parameters to new() must be a HASH ref"
#            . " data => ". $_[0])
#      : @_ % 2
#        ? Carp::croak("The new() method for $class expects a hash reference or a"
#            . " key/value list. You passed an odd number of arguments")
#        : {@_}
#    ;
#_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 = $test{$_};
#    my $arg_key = quotify($arg);
#    my $test = defined $arg ? "exists \$args->{$arg_key}" : undef;
#    my $source = defined $arg ? "\$args->{$arg_key}" : undef;
#    my $attr_spec = $spec->{$_};
#    $self->_cap_call($ag->generate_populate_set(
#      '$new', $_, $attr_spec, $source, $test, $arg,
#    ));
#  } 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{      Carp::croak("Missing required arguments: ".CORE::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' },
#);
#if ($INC{'Moo/HandleMoose.pm'} && !$Moo::sification::disabled) {
#  Moo::HandleMoose::inject_fake_metaclass_for(__PACKAGE__);
#}
#
#1;
### Method/Generate/DemolishAll.pm ###
#package Method::Generate::DemolishAll;
#
#use Moo::_strictures;
#use Moo::Object ();
#BEGIN { our @ISA = qw(Moo::Object) }
#use Sub::Quote qw(quote_sub quotify);
#use Moo::_Utils qw(_getglob);
#use Moo::_mro;
#
#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;
### Mo.pm ###
#package Mo;
#$Mo::VERSION = '0.40';
#$VERSION='0.40';
#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.40';
#
#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.40';
#
#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;
#$Mo::Moose::VERSION = '0.40';$M="Mo::";
#$VERSION='0.40';
#*{$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;
#$Attr::Trait::VERSION = '0.40';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;
#$Mo::Mouse::VERSION = '0.40';$M="Mo::";
#$VERSION='0.40';
#*{$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;
#$Attr::Trait::VERSION = '0.40';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;
#$Mo::build::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#*{$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;
#$Mo::builder::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#*{$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;
#$Mo::chain::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#*{$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;
#$Mo::coerce::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#*{$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;
#$Mo::default::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#*{$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;
#$Mo::exporter::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#*{$M.'exporter::e'}=sub{my($P)=@_;if(@{$M.EXPORT}){*{$P.$_}=\&{$M.$_}for@{$M.EXPORT}}};
### Mo/import.pm ###
#package Mo::import;
#$Mo::import::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#my$i=\&import;*{$M.import}=sub{(@_==2 and not$_[1])?pop@_:@_==1?push@_,grep!/import/,@f:();goto&$i};
### Mo/importer.pm ###
#package Mo::importer;
#$Mo::importer::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#*{$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;
#$Mo::is::VERSION = '0.40';$M="Mo::";
#$VERSION='0.40';
#*{$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;
#$Mo::nonlazy::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#*{$M.'nonlazy::e'}=sub{${shift().':N'}=1};
### Mo/option.pm ###
#package Mo::option;
#$Mo::option::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#*{$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;
#$Mo::required::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#*{$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;
#$Mo::xs::VERSION = '0.40';my$M="Mo::";
#$VERSION='0.40';
#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/Installed/Tiny.pm ###
#package Module::Installed::Tiny;
#
#our $DATE = '2016-08-04'; 
#our $VERSION = '0.003'; 
#
#use strict;
#use warnings;
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(module_installed module_source);
#
#our $SEPARATOR;
#BEGIN {
#    if ($^O =~ /^(dos|os2)/i) {
#        $SEPARATOR = '\\';
#    } elsif ($^O =~ /^MacOS/i) {
#        $SEPARATOR = ':';
#    } else {
#        $SEPARATOR = '/';
#    }
#}
#
#sub _module_source {
#    my $name_pm = shift;
#
#    for my $entry (@INC) {
#        next unless defined $entry;
#        my $ref = ref($entry);
#        my ($is_hook, @hook_res);
#        if ($ref eq 'ARRAY') {
#            $is_hook++;
#            @hook_res = $entry->[0]->($entry, $name_pm);
#        } elsif (UNIVERSAL::can($entry, 'INC')) {
#            $is_hook++;
#            @hook_res = $entry->INC($name_pm);
#        } elsif ($ref eq 'CODE') {
#            $is_hook++;
#            @hook_res = $entry->($entry, $name_pm);
#        } else {
#            my $path = "$entry$SEPARATOR$name_pm";
#            if (-f $path) {
#                open my($fh), "<", $path
#                    or die "Can't locate $name_pm: $path: $!";
#                local $/;
#                return scalar <$fh>;
#            }
#        }
#
#        if ($is_hook) {
#            next unless @hook_res;
#            my $prepend_ref = shift @hook_res if ref($hook_res[0]) eq 'SCALAR';
#            my $fh          = shift @hook_res if ref($hook_res[0]) eq 'GLOB';
#            my $code        = shift @hook_res if ref($hook_res[0]) eq 'CODE';
#            my $code_state  = shift @hook_res if @hook_res;
#            if ($fh) {
#                my $src = "";
#                local $_;
#                while (!eof($fh)) {
#                    $_ = <$fh>;
#                    if ($code) {
#                        $code->($code, $code_state);
#                    }
#                    $src .= $_;
#                }
#                $src = $$prepend_ref . $src if $prepend_ref;
#                return $src;
#            } elsif ($code) {
#                my $src = "";
#                local $_;
#                while ($code->($code, $code_state)) {
#                    $src .= $_;
#                }
#                $src = $$prepend_ref . $src if $prepend_ref;
#                return $src;
#            }
#        }
#    }
#
#    die "Can't locate $name_pm in \@INC (\@INC contains: ".join(" ", @INC).")";
#}
#
#sub module_source {
#    my $name = shift;
#
#    my $name_pm;
#    if ($name =~ /\A\w+(?:::\w+)*\z/) {
#        ($name_pm = "$name.pm") =~ s!::!$SEPARATOR!g;
#    } else {
#        $name_pm = $name;
#    }
#
#    _module_source $name_pm;
#}
#
#sub module_installed {
#    my $name = shift;
#
#    my $name_pm;
#    if ($name =~ /\A\w+(?:::\w+)*\z/) {
#        ($name_pm = "$name.pm") =~ s!::!$SEPARATOR!g;
#    } else {
#        $name_pm = $name;
#    }
#
#    return 1 if exists $INC{$name_pm};
#
#    if (eval { _module_source $name_pm; 1 }) {
#        1;
#    } else {
#        0;
#    }
#}
#
#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 = '2017-02-01'; 
#our $VERSION = '0.33'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#require Exporter;
#our @ISA       = qw(Exporter);
#our @EXPORT_OK = qw(module_path pod_path);
#
#our $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 <pm: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  => ['int*', min=>0],
#            default => 1,
#            description => <<'_',
#
#The value of this option is an integer number from 0. 0 means to not search for
#.pm files, while number larger than 0 means to search for .pm files. The larger
#the number, the lower the priority. If more than one type is found (prefix, .pm,
#.pmc, .pod) then the type with the lowest number is returned first.
#
#_
#        },
#        find_pmc => {
#            summary => 'Whether to find .pmc files',
#            schema  => ['int*', min=>0],
#            default => 2,
#            description => <<'_',
#
#The value of this option is an integer number from 0. 0 means to not search for
#.pmc files, while number larger than 0 means to search for .pmc files. The
#larger the number, the lower the priority. If more than one type is found
#(prefix, .pm, .pmc, .pod) then the type with the lowest number is returned
#first.
#
#_
#        },
#        find_pod => {
#            summary => 'Whether to find .pod files',
#            schema  => ['int*', min=>0],
#            default => 0,
#            description => <<'_',
#
#The value of this option is an integer number from 0. 0 means to not search for
#.pod files, while number larger than 0 means to search for .pod files. The
#larger the number, the lower the priority. If more than one type is found
#(prefix, .pm, .pmc, .pod) then the type with the lowest number is returned
#first.
#
#_
#        },
#        find_prefix => {
#            summary => 'Whether to find module prefixes',
#            schema  => ['int*', min=>0],
#            default => 0,
#            description => <<'_',
#
#The value of this option is an integer number from 0. 0 means to not search for
#module prefix, while number larger than 0 means to search for module prefix. The
#larger the number, the lower the priority. If more than one type is found
#(prefix, .pm, .pmc, .pod) then the type with the lowest number is returned
#first.
#
#_
#        },
#        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,
#    examples => [
#        {
#            summary => 'Find the first Foo::Bar (.pm or .pmc) in @INC',
#            args => {module => 'Foo::Bar'},
#        },
#        {
#            summary => 'Find all Foo::Bar (.pm or .pmc) in @INC, return absolute paths',
#            args => {module => 'Foo::Bar', all => 1, abs => 1},
#        },
#        {
#            summary => 'Find the Rinci (.pod first, then .pm) in @INC',
#            args => {module => 'Rinci', find_pod => 1, find_pm => 2, find_pmc => 0},
#        },
#    ],
#};
#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}    //= 2;
#    $args{find_pod}    //= 0;
#    $args{find_prefix} //= 0;
#
#    require Cwd if $args{abs};
#
#    my @res;
#    my %unfound = (
#        ("pm" => 1)     x !!$args{find_pm},
#        ("pmc" => 1)    x !!$args{find_pmc},
#        ("pod" => 1)    x !!$args{find_pod},
#        ("prefix" => 1) x !!$args{find_prefix},
#    );
#    my $add = sub {
#        my ($path, $prio) = @_;
#        push @res, [$args{abs} ? Cwd::abs_path($path) : $path, $prio];
#    };
#
#    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_pm}) {
#            my $file = $prefix . ".pm";
#            if (-f $file) {
#                $add->($file, $args{find_pm});
#                delete $unfound{pm};
#                last if !keys(%unfound) && !$args{all};
#            }
#        }
#        if ($args{find_pmc}) {
#            my $file = $prefix . ".pmc";
#            if (-f $file) {
#                $add->($file, $args{find_pmc});
#                delete $unfound{pmc};
#                last if !keys(%unfound) && !$args{all};
#            }
#        }
#        if ($args{find_pod}) {
#            my $file = $prefix . ".pod";
#            if (-f $file) {
#                $add->($file, $args{find_pod});
#                delete $unfound{pod};
#                last if !keys(%unfound) && !$args{all};
#            }
#        }
#        if ($args{find_prefix}) {
#            if (-d $prefix) {
#                $add->($prefix, $args{find_prefix});
#                delete $unfound{prefix};
#                last if !keys(%unfound) && !$args{all};
#            }
#        }
#    }
#
#    @res = map { $_->[0] } sort { $a->[1] <=> $b->[1] } @res;
#
#    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::_mro;
#use Moo::_Utils qw(
#  _getglob
#  _getstash
#  _install_coderef
#  _install_modifier
#  _load_module
#  _set_loaded
#  _unimport_coderefs
#);
#use Carp qw(croak);
#BEGIN {
#  our @CARP_NOT = qw(
#    Method::Generate::Constructor
#    Method::Generate::Accessor
#    Moo::sification
#    Moo::_Utils
#    Moo::Role
#  );
#}
#
#our $VERSION = '2.002004';
#$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)) {
#    croak "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) {
#      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 {
#      _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::sification::disabled) {
#    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)) {
#      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::sification::disabled) {
#    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"
#        .'          package '.$target.';'."\n"
#        .'          return $invoker->SUPER::new(@_);'."\n"
#        .'        }'."\n"
#        .'        '.$class.'->_constructor_maker_for($class);'."\n"
#        .'        return $invoker->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;'
#          .'  $invoker->'.$target.'::SUPER::new($args);'
#          .'}'
#        };
#      }
#      else {
#        $construct_opts{construction_builder} = sub {
#          '$invoker->'.$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 qw(_getstash);
#use Sub::Quote qw(quotify);
#use Carp qw(croak);
#
#our %TYPE_MAP;
#
#our $SETUP_DONE;
#
#sub import { return if $SETUP_DONE; inject_all(); $SETUP_DONE = 1; }
#
#sub inject_all {
#  croak "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), {}, [] )
#    }
#  };
#
#  {
#    local $DID_INJECT{$name} = 1;
#    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};
#    }
#
#    $methods{$_} = Sub::Defer::undefer_sub($methods{$_})
#      for
#        grep $_ ne 'new',
#        keys %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") ) {
#                croak "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 ($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;
#use Carp ();
#BEGIN { our @CARP_NOT = qw(Moo::HandleMoose) }
#
#sub DESTROY { }
#
#sub AUTOLOAD {
#  my ($meth) = (our $AUTOLOAD =~ /([^:]+)$/);
#  my $self = shift;
#  Carp::croak "Can't call $meth without object instance"
#    if !ref $self;
#  Carp::croak "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 $type = $1;
#    my $id = do { no warnings 'portable'; hex "$2" };
#    require B;
#    my $sv = bless \$id, 'B::SV';
#    my $ref = eval { $sv->object_2svref };
#    if (!defined $ref or Scalar::Util::reftype($ref) ne $type) {
#      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;
#use Carp ();
#
#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;
#  scalar @_ == 1
#    ? ref $_[0] eq 'HASH'
#      ? { %{ $_[0] } }
#      : Carp::croak("Single parameters to new() must be a HASH ref"
#          . " data => ". $_[0])
#    : @_ % 2
#      ? Carp::croak("The new() method for $class expects a hash reference or a"
#          . " key/value list. You passed an odd number of arguments")
#      : {@_}
#  ;
#}
#
#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 qw(
#  _getglob
#  _getstash
#  _install_coderef
#  _install_modifier
#  _load_module
#  _name_coderef
#  _set_loaded
#  _unimport_coderefs
#);
#use Sub::Defer ();
#use Sub::Quote qw(quote_sub sanitize_identifier);
#use Role::Tiny ();
#use Carp qw(croak);
#BEGIN { our @ISA = qw(Role::Tiny) }
#BEGIN {
#  our @CARP_NOT = qw(
#    Method::Generate::Accessor
#    Method::Generate::Constructor
#    Moo::sification
#    Moo::_Utils
#  );
#}
#
#our $VERSION = '2.002004';
#$VERSION = eval $VERSION;
#
#require Moo::sification;
#Moo::sification->import;
#
#BEGIN {
#    *INFO = \%Role::Tiny::INFO;
#    *APPLIED_TO = \%Role::Tiny::APPLIED_TO;
#    *COMPOSED = \%Role::Tiny::COMPOSED;
#    *ON_ROLE_CREATE = \@Role::Tiny::ON_ROLE_CREATE;
#}
#
#our %INFO;
#our %APPLIED_TO;
#our %APPLY_DEFAULTS;
#our %COMPOSED;
#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;
#  if ($Moo::MAKERS{$target} and $Moo::MAKERS{$target}{is_class}) {
#    croak "Cannot import Moo::Role into a Moo class";
#  }
#  _set_loaded(caller);
#  goto &Role::Tiny::import;
#}
#
#sub _install_subs {
#  my ($me, $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) {
#      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 {
#      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);
#  };
#  *{_getglob("${target}::meta")} = $me->can('meta');
#}
#
#push @ON_ROLE_CREATE, sub {
#  my $target = shift;
#  if ($INC{'Moo/HandleMoose.pm'} && !$Moo::sification::disabled) {
#    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::sification::disabled) {
#    Moo::HandleMoose::maybe_reinject_fake_metaclass_for($target);
#  }
#}
#
#sub methods_provided_by {
#  my ($self, $role) = @_;
#  _load_module($role);
#  $self->_inhale_if_moose($role);
#  croak "${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;
#          my $tc_var = '$_check_for_'.sanitize_identifier($tc->name);
#
#          $spec->{isa} = quote_sub
#            qq{
#              &${tc_var} or Carp::croak "Type constraint failed for \$_[0]"
#            },
#            { $tc_var => \$check },
#            {
#              package => $role,
#            },
#          ;
#
#          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 ];
#        }
#      }
#    }
#    $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 _undefer_subs {
#  my ($self, $target, $role) = @_;
#  Sub::Defer::undefer_package($role);
#}
#
#sub role_application_steps {
#  qw(_handle_constructor _undefer_subs _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);
#    croak "${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);
#  croak "${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 $COMPOSED{class}{$new_name};
#
#  foreach my $role (@roles) {
#    _load_module($role);
#    $me->_inhale_if_moose($role);
#    croak "${role} is not a Moo::Role" unless $me->is_role($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);
#  }
#  else {
#    $me->SUPER::create_class_with_roles($superclass, @roles);
#    $Moo::MAKERS{$new_name} = {is_class => 1};
#    $me->_handle_constructor($new_name, $_) for @roles;
#  }
#
#  if ($INC{'Moo/HandleMoose.pm'} && !$Moo::sification::disabled) {
#    Moo::HandleMoose::inject_fake_metaclass_for($new_name);
#  }
#  _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);
#  my $class = ref $new;
#  _set_loaded($class, (caller)[1]);
#
#  my $apply_defaults = exists $APPLY_DEFAULTS{$class} ? $APPLY_DEFAULTS{$class}
#    : $APPLY_DEFAULTS{$class} = do {
#    my %attrs = map { @{$INFO{$_}{attributes}||[]} } @roles;
#
#    if ($INC{'Moo.pm'}
#        and keys %attrs
#        and my $con_gen = Moo->_constructor_maker_for($class)
#        and my $m = Moo->_accessor_maker_for($class)) {
#      require Sub::Quote;
#
#      my $specs = $con_gen->all_attribute_specs;
#
#      my %captures;
#      my $code = join('',
#        "no warnings 'void';\n",
#        ( map {
#          my $name = $_;
#          my $spec = $specs->{$name};
#          if ($m->has_eager_default($name, $spec)) {
#            my ($has, $has_cap)
#              = $m->generate_simple_has('$_[0]', $name, $spec);
#            my ($set, $pop_cap)
#              = $m->generate_use_default('$_[0]', $name, $spec, $has);
#
#            @captures{keys %$has_cap, keys %$pop_cap}
#              = (values %$has_cap, values %$pop_cap);
#            "($set),";
#          }
#          else {
#            ();
#          }
#        } sort keys %attrs ),
#      );
#      Sub::Quote::quote_sub(
#        "${class}::_apply_defaults",
#        $code,
#        \%captures,
#        {
#          package => $class,
#          no_install => 1,
#        }
#      );
#    }
#    else {
#      0;
#    }
#  };
#  if ($apply_defaults) {
#    local $Carp::Internal{+__PACKAGE__} = 1;
#    local $Carp::Internal{$class} = 1;
#    $new->$apply_defaults;
#  }
#  return $new;
#}
#
#sub _composable_package_for {
#  my ($self, $role) = @_;
#  my $composed_name = 'Role::Tiny::_COMPOSABLE::'.$role;
#  return $composed_name if $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 Moo::_strictures;
#
#BEGIN {
#  my ($su, $sn);
#  $su = $INC{'Sub/Util.pm'} && defined &Sub::Util::set_subname
#    or $sn = $INC{'Sub/Name.pm'}
#    or $su = eval { require Sub::Util; } && defined &Sub::Util::set_subname
#    or $sn = eval { require Sub::Name; };
#
#  *_subname = $su ? \&Sub::Util::set_subname
#            : $sn ? \&Sub::Name::subname
#            : sub { $_[1] };
#  *_CAN_SUBNAME = ($su || $sn) ? sub(){1} : sub(){0};
#}
#
#use Module::Runtime qw(use_package_optimistically module_notional_filename);
#
#use Devel::GlobalDestruction ();
#use Exporter qw(import);
#use Config;
#use Carp qw(croak);
#
#our @EXPORT = qw(
#    _getglob _install_modifier _load_module _maybe_load_module
#    _getstash _install_coderef _name_coderef
#    _unimport_coderefs _set_loaded
#);
#
#sub _install_modifier {
#  my ($into, $type, $name, $code) = @_;
#
#  if (my $to_modify = $into->can($name)) { 
#    require Sub::Defer;
#    Sub::Defer::undefer_sub($to_modify);
#  }
#
#  require Class::Method::Modifiers;
#  Class::Method::Modifiers::install_modifier(@_);
#}
#
#sub _load_module {
#  my $module = $_[0];
#  my $file = eval { module_notional_filename($module) } or croak $@;
#  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);
#  croak $error;
#}
#
#our %MAYBE_LOADED;
#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 _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_SUBNAME ? _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_000) {
#  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);
#use Carp qw(croak);
#BEGIN { our @CARP_NOT = qw(Moo::HandleMoose) }
#
#sub unimport {
#  croak "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;
### Net/HTTP.pm ###
#package Net::HTTP;
#
#use strict;
#use vars qw($VERSION @ISA $SOCKET_CLASS);
#
#$VERSION = "6.09";
#$VERSION = eval $VERSION;
#
#unless ($SOCKET_CLASS) {
#    if (eval { require IO::Socket::IP }) {
#       $SOCKET_CLASS = "IO::Socket::IP";    
#    } elsif (eval { require IO::Socket::INET6 }) {
#       $SOCKET_CLASS = "IO::Socket::INET6"; 
#    } elsif (eval { require IO::Socket::INET }) {
#       $SOCKET_CLASS = "IO::Socket::INET";  
#    } else {
#       require IO::Socket;
#       $SOCKET_CLASS = "IO::Socket::INET";
#    }
#}
#require Net::HTTP::Methods;
#require Carp;
#
#@ISA = ($SOCKET_CLASS, 'Net::HTTP::Methods');
#
#sub new {
#    my $class = shift;
#    Carp::croak("No Host option provided") unless @_;
#    $class->SUPER::new(@_);
#}
#
#sub configure {
#    my($self, $cnf) = @_;
#    $self->http_configure($cnf);
#}
#
#sub http_connect {
#    my($self, $cnf) = @_;
#    $self->SUPER::configure($cnf);
#}
#
#1;
#
#__END__
#
### Net/HTTP/Methods.pm ###
#package Net::HTTP::Methods;
#
#require 5.005;  
#
#use strict;
#use vars qw($VERSION);
#use URI;
#
#$VERSION = "6.09";
#$VERSION = eval $VERSION;
#
#my $CRLF = "\015\012";   
#
#*_bytes = defined(&utf8::downgrade) ?
#    sub {
#        unless (utf8::downgrade($_[0], 1)) {
#            require Carp;
#            Carp::croak("Wide character in HTTP request (bytes required)");
#        }
#        return $_[0];
#    }
#    :
#    sub {
#        return $_[0];
#    };
#
#
#sub new {
#    my $class = shift;
#    unshift(@_, "Host") if @_ == 1;
#    my %cnf = @_;
#    require Symbol;
#    my $self = bless Symbol::gensym(), $class;
#    return $self->http_configure(\%cnf);
#}
#
#sub http_configure {
#    my($self, $cnf) = @_;
#
#    die "Listen option not allowed" if $cnf->{Listen};
#    my $explicit_host = (exists $cnf->{Host});
#    my $host = delete $cnf->{Host};
#    my $peer = $cnf->{PeerAddr} || $cnf->{PeerHost};
#    if (!$peer) {
#	die "No Host option provided" unless $host;
#	$cnf->{PeerAddr} = $peer = $host;
#    }
#
#    my $peer_uri = URI->new("http://$peer");
#    $cnf->{"PeerPort"} =  $peer_uri->_port || $cnf->{PeerPort} ||  $self->http_default_port;
#    $cnf->{"PeerAddr"} = $peer_uri->host;
#
#    if (($host) || (! $explicit_host)) {
#        my $uri =  ($explicit_host) ? URI->new("http://$host") : $peer_uri->clone;
#        if (!$uri->_port) {
#            $uri->port( $cnf->{PeerPort} ||  $self->http_default_port);
#        }
#        my $host_port = $uri->host_port;               
#        my $remove = ":" . $self->http_default_port;   
#        if (substr($host_port,0-length($remove)) eq $remove) {
#            substr($host_port,0-length($remove)) = "";
#        }
#        $host = $host_port;
#    }
#
#    $cnf->{Proto} = 'tcp';
#
#    my $keep_alive = delete $cnf->{KeepAlive};
#    my $http_version = delete $cnf->{HTTPVersion};
#    $http_version = "1.1" unless defined $http_version;
#    my $peer_http_version = delete $cnf->{PeerHTTPVersion};
#    $peer_http_version = "1.0" unless defined $peer_http_version;
#    my $send_te = delete $cnf->{SendTE};
#    my $max_line_length = delete $cnf->{MaxLineLength};
#    $max_line_length = 8*1024 unless defined $max_line_length;
#    my $max_header_lines = delete $cnf->{MaxHeaderLines};
#    $max_header_lines = 128 unless defined $max_header_lines;
#
#    return undef unless $self->http_connect($cnf);
#
#    $self->host($host);
#    $self->keep_alive($keep_alive);
#    $self->send_te($send_te);
#    $self->http_version($http_version);
#    $self->peer_http_version($peer_http_version);
#    $self->max_line_length($max_line_length);
#    $self->max_header_lines($max_header_lines);
#
#    ${*$self}{'http_buf'} = "";
#
#    return $self;
#}
#
#sub http_default_port {
#    80;
#}
#
#for my $method (qw(host keep_alive send_te max_line_length max_header_lines peer_http_version)) {
#    my $prop_name = "http_" . $method;
#    no strict 'refs';
#    *$method = sub {
#	my $self = shift;
#	my $old = ${*$self}{$prop_name};
#	${*$self}{$prop_name} = shift if @_;
#	return $old;
#    };
#}
#
#sub http_version {
#    my $self = shift;
#    my $old = ${*$self}{'http_version'};
#    if (@_) {
#	my $v = shift;
#	$v = "1.0" if $v eq "1";  
#	unless ($v eq "1.0" or $v eq "1.1") {
#	    require Carp;
#	    Carp::croak("Unsupported HTTP version '$v'");
#	}
#	${*$self}{'http_version'} = $v;
#    }
#    $old;
#}
#
#sub format_request {
#    my $self = shift;
#    my $method = shift;
#    my $uri = shift;
#
#    my $content = (@_ % 2) ? pop : "";
#
#    for ($method, $uri) {
#	require Carp;
#	Carp::croak("Bad method or uri") if /\s/ || !length;
#    }
#
#    push(@{${*$self}{'http_request_method'}}, $method);
#    my $ver = ${*$self}{'http_version'};
#    my $peer_ver = ${*$self}{'http_peer_http_version'} || "1.0";
#
#    my @h;
#    my @connection;
#    my %given = (host => 0, "content-length" => 0, "te" => 0);
#    while (@_) {
#	my($k, $v) = splice(@_, 0, 2);
#	my $lc_k = lc($k);
#	if ($lc_k eq "connection") {
#	    $v =~ s/^\s+//;
#	    $v =~ s/\s+$//;
#	    push(@connection, split(/\s*,\s*/, $v));
#	    next;
#	}
#	if (exists $given{$lc_k}) {
#	    $given{$lc_k}++;
#	}
#	push(@h, "$k: $v");
#    }
#
#    if (length($content) && !$given{'content-length'}) {
#	push(@h, "Content-Length: " . length($content));
#    }
#
#    my @h2;
#    if ($given{te}) {
#	push(@connection, "TE") unless grep lc($_) eq "te", @connection;
#    }
#    elsif ($self->send_te && gunzip_ok()) {
#	push(@h2, "TE: deflate,gzip;q=0.3");
#	push(@connection, "TE");
#    }
#
#    unless (grep lc($_) eq "close", @connection) {
#	if ($self->keep_alive) {
#	    if ($peer_ver eq "1.0") {
#		push(@h2, "Keep-Alive: 300");
#		unshift(@connection, "Keep-Alive");
#	    }
#	}
#	else {
#	    push(@connection, "close") if $ver ge "1.1";
#	}
#    }
#    push(@h2, "Connection: " . join(", ", @connection)) if @connection;
#    unless ($given{host}) {
#	my $h = ${*$self}{'http_host'};
#	push(@h2, "Host: $h") if $h;
#    }
#
#    return _bytes(join($CRLF, "$method $uri HTTP/$ver", @h2, @h, "", $content));
#}
#
#
#sub write_request {
#    my $self = shift;
#    $self->print($self->format_request(@_));
#}
#
#sub format_chunk {
#    my $self = shift;
#    return $_[0] unless defined($_[0]) && length($_[0]);
#    return _bytes(sprintf("%x", length($_[0])) . $CRLF . $_[0] . $CRLF);
#}
#
#sub write_chunk {
#    my $self = shift;
#    return 1 unless defined($_[0]) && length($_[0]);
#    $self->print(_bytes(sprintf("%x", length($_[0])) . $CRLF . $_[0] . $CRLF));
#}
#
#sub format_chunk_eof {
#    my $self = shift;
#    my @h;
#    while (@_) {
#	push(@h, sprintf "%s: %s$CRLF", splice(@_, 0, 2));
#    }
#    return _bytes(join("", "0$CRLF", @h, $CRLF));
#}
#
#sub write_chunk_eof {
#    my $self = shift;
#    $self->print($self->format_chunk_eof(@_));
#}
#
#
#sub my_read {
#    die if @_ > 3;
#    my $self = shift;
#    my $len = $_[1];
#    for (${*$self}{'http_buf'}) {
#	if (length) {
#	    $_[0] = substr($_, 0, $len, "");
#	    return length($_[0]);
#	}
#	else {
#	    die "read timeout" unless $self->can_read;
#	    return $self->sysread($_[0], $len);
#	}
#    }
#}
#
#
#sub my_readline {
#    my $self = shift;
#    my $what = shift;
#    for (${*$self}{'http_buf'}) {
#	my $max_line_length = ${*$self}{'http_max_line_length'};
#	my $pos;
#	while (1) {
#	    $pos = index($_, "\012");
#	    last if $pos >= 0;
#	    die "$what line too long (limit is $max_line_length)"
#		if $max_line_length && length($_) > $max_line_length;
#
#            my $new_bytes = 0;
#
#          READ:
#            {   
#                $self->can_read
#                     or die "read timeout";
#
#                while(1) {
#                    my $bytes_read = $self->sysread($_, 1024, length);
#                    if(defined $bytes_read) {
#                        $new_bytes += $bytes_read;
#                        last if $bytes_read < 1024;
#                    }
#                    elsif($!{EINTR} || $!{EAGAIN} || $!{EWOULDBLOCK}) {
#                        redo READ;
#                    }
#                    else {
#                        length or die "$what read failed: $!";
#                        last;
#                    }
#                }
#
#                return length($_) ? substr($_, 0, length($_), "") : undef
#                    if $new_bytes==0;
#            }
#	}
#	die "$what line too long ($pos; limit is $max_line_length)"
#	    if $max_line_length && $pos > $max_line_length;
#
#	my $line = substr($_, 0, $pos+1, "");
#	$line =~ s/(\015?\012)\z// || die "Assert";
#	return wantarray ? ($line, $1) : $line;
#    }
#}
#
#
#sub can_read {
#    my $self = shift;
#    return 1 unless defined(fileno($self));
#    return 1 if $self->isa('IO::Socket::SSL') && $self->pending;
#
#    my $timeout = @_ ? shift : (${*$self}{io_socket_timeout} || undef);
#
#    my $fbits = '';
#    vec($fbits, fileno($self), 1) = 1;
#  SELECT:
#    {
#        my $before;
#        $before = time if $timeout;
#        my $nfound = select($fbits, undef, undef, $timeout);
#        if ($nfound < 0) {
#            if ($!{EINTR} || $!{EAGAIN}) {
#                if ($timeout) {
#                    $timeout -= time - $before;
#                    $timeout = 0 if $timeout < 0;
#                }
#                redo SELECT;
#            }
#            die "select failed: $!";
#        }
#        return $nfound > 0;
#    }
#}
#
#
#sub _rbuf {
#    my $self = shift;
#    if (@_) {
#	for (${*$self}{'http_buf'}) {
#	    my $old;
#	    $old = $_ if defined wantarray;
#	    $_ = shift;
#	    return $old;
#	}
#    }
#    else {
#	return ${*$self}{'http_buf'};
#    }
#}
#
#sub _rbuf_length {
#    my $self = shift;
#    return length ${*$self}{'http_buf'};
#}
#
#
#sub _read_header_lines {
#    my $self = shift;
#    my $junk_out = shift;
#
#    my @headers;
#    my $line_count = 0;
#    my $max_header_lines = ${*$self}{'http_max_header_lines'};
#    while (my $line = my_readline($self, 'Header')) {
#	if ($line =~ /^(\S+?)\s*:\s*(.*)/s) {
#	    push(@headers, $1, $2);
#	}
#	elsif (@headers && $line =~ s/^\s+//) {
#	    $headers[-1] .= " " . $line;
#	}
#	elsif ($junk_out) {
#	    push(@$junk_out, $line);
#	}
#	else {
#	    die "Bad header: '$line'\n";
#	}
#	if ($max_header_lines) {
#	    $line_count++;
#	    if ($line_count >= $max_header_lines) {
#		die "Too many header lines (limit is $max_header_lines)";
#	    }
#	}
#    }
#    return @headers;
#}
#
#
#sub read_response_headers {
#    my($self, %opt) = @_;
#    my $laxed = $opt{laxed};
#
#    my($status, $eol) = my_readline($self, 'Status');
#    unless (defined $status) {
#	die "Server closed connection without sending any data back";
#    }
#
#    my($peer_ver, $code, $message) = split(/\s+/, $status, 3);
#    if (!$peer_ver || $peer_ver !~ s,^HTTP/,, || $code !~ /^[1-5]\d\d$/) {
#	die "Bad response status line: '$status'" unless $laxed;
#	${*$self}{'http_peer_http_version'} = "0.9";
#	${*$self}{'http_status'} = "200";
#	substr(${*$self}{'http_buf'}, 0, 0) = $status . ($eol || "");
#	return 200 unless wantarray;
#	return (200, "Assumed OK");
#    };
#
#    ${*$self}{'http_peer_http_version'} = $peer_ver;
#    ${*$self}{'http_status'} = $code;
#
#    my $junk_out;
#    if ($laxed) {
#	$junk_out = $opt{junk_out} || [];
#    }
#    my @headers = $self->_read_header_lines($junk_out);
#
#    my @te;
#    my $content_length;
#    for (my $i = 0; $i < @headers; $i += 2) {
#	my $h = lc($headers[$i]);
#	if ($h eq 'transfer-encoding') {
#	    my $te = $headers[$i+1];
#	    $te =~ s/^\s+//;
#	    $te =~ s/\s+$//;
#	    push(@te, $te) if length($te);
#	}
#	elsif ($h eq 'content-length') {
#	    if ($headers[$i+1] =~ /^\s*(\d{1,15})(?:\s|$)/) {
#		$content_length = $1;
#	    }
#	}
#    }
#    ${*$self}{'http_te'} = join(",", @te);
#    ${*$self}{'http_content_length'} = $content_length;
#    ${*$self}{'http_first_body'}++;
#    delete ${*$self}{'http_trailers'};
#    return $code unless wantarray;
#    return ($code, $message, @headers);
#}
#
#
#sub read_entity_body {
#    my $self = shift;
#    my $buf_ref = \$_[0];
#    my $size = $_[1];
#    die "Offset not supported yet" if $_[2];
#
#    my $chunked;
#    my $bytes;
#
#    if (${*$self}{'http_first_body'}) {
#	${*$self}{'http_first_body'} = 0;
#	delete ${*$self}{'http_chunked'};
#	delete ${*$self}{'http_bytes'};
#	my $method = shift(@{${*$self}{'http_request_method'}});
#	my $status = ${*$self}{'http_status'};
#	if ($method eq "HEAD") {
#	    $bytes = 0;
#	}
#	elsif (my $te = ${*$self}{'http_te'}) {
#	    my @te = split(/\s*,\s*/, lc($te));
#	    die "Chunked must be last Transfer-Encoding '$te'"
#		unless pop(@te) eq "chunked";
#	    pop(@te) while @te && $te[-1] eq "chunked";  
#
#	    for (@te) {
#		if ($_ eq "deflate" && inflate_ok()) {
#		    my ($i, $status) = Compress::Raw::Zlib::Inflate->new();
#		    die "Can't make inflator: $status" unless $i;
#		    $_ = sub { my $out; $i->inflate($_[0], \$out); $out }
#		}
#		elsif ($_ eq "gzip" && gunzip_ok()) {
#		    my @buf;
#		    $_ = sub {
#			push(@buf, $_[0]);
#			return "" unless $_[1];
#			my $input = join("", @buf);
#			my $output;
#			IO::Uncompress::Gunzip::gunzip(\$input, \$output, Transparent => 0)
#			    or die "Can't gunzip content: $IO::Uncompress::Gunzip::GunzipError";
#			return \$output;
#		    };
#		}
#		elsif ($_ eq "identity") {
#		    $_ = sub { $_[0] };
#		}
#		else {
#		    die "Can't handle transfer encoding '$te'";
#		}
#	    }
#
#	    @te = reverse(@te);
#
#	    ${*$self}{'http_te2'} = @te ? \@te : "";
#	    $chunked = -1;
#	}
#	elsif (defined(my $content_length = ${*$self}{'http_content_length'})) {
#	    $bytes = $content_length;
#	}
#        elsif ($status =~ /^(?:1|[23]04)/) {
#            $bytes = 0;
#        }
#	else {
#
#	}
#    }
#    else {
#	$chunked = ${*$self}{'http_chunked'};
#	$bytes   = ${*$self}{'http_bytes'};
#    }
#
#    if (defined $chunked) {
#
#	if ($chunked <= 0) {
#	    my $line = my_readline($self, 'Entity body');
#	    if ($chunked == 0) {
#		die "Missing newline after chunk data: '$line'"
#		    if !defined($line) || $line ne "";
#		$line = my_readline($self, 'Entity body');
#	    }
#	    die "EOF when chunk header expected" unless defined($line);
#	    my $chunk_len = $line;
#	    $chunk_len =~ s/;.*//;  
#	    unless ($chunk_len =~ /^([\da-fA-F]+)\s*$/) {
#		die "Bad chunk-size in HTTP response: $line";
#	    }
#	    $chunked = hex($1);
#	    ${*$self}{'http_chunked'} = $chunked;
#	    if ($chunked == 0) {
#		${*$self}{'http_trailers'} = [$self->_read_header_lines];
#		$$buf_ref = "";
#
#		my $n = 0;
#		if (my $transforms = delete ${*$self}{'http_te2'}) {
#		    for (@$transforms) {
#			$$buf_ref = &$_($$buf_ref, 1);
#		    }
#		    $n = length($$buf_ref);
#		}
#
#		delete ${*$self}{'http_chunked'};
#		${*$self}{'http_bytes'} = 0;
#
#		return $n;
#	    }
#	}
#
#	my $n = $chunked;
#	$n = $size if $size && $size < $n;
#	$n = my_read($self, $$buf_ref, $n);
#	return undef unless defined $n;
#
#	${*$self}{'http_chunked'} = $chunked - $n;
#
#	if ($n > 0) {
#	    if (my $transforms = ${*$self}{'http_te2'}) {
#		for (@$transforms) {
#		    $$buf_ref = &$_($$buf_ref, 0);
#		}
#		$n = length($$buf_ref);
#		$n = -1 if $n == 0;
#	    }
#	}
#	return $n;
#    }
#    elsif (defined $bytes) {
#	unless ($bytes) {
#	    $$buf_ref = "";
#	    return 0;
#	}
#	my $n = $bytes;
#	$n = $size if $size && $size < $n;
#	$n = my_read($self, $$buf_ref, $n);
#	${*$self}{'http_bytes'} = defined $n ? $bytes - $n : $bytes;
#	return $n;
#    }
#    else {
#	$size ||= 8*1024;
#	return my_read($self, $$buf_ref, $size);
#    }
#}
#
#sub get_trailers {
#    my $self = shift;
#    @{${*$self}{'http_trailers'} || []};
#}
#
#BEGIN {
#my $gunzip_ok;
#my $inflate_ok;
#
#sub gunzip_ok {
#    return $gunzip_ok if defined $gunzip_ok;
#
#    local $@;
#    local $SIG{__DIE__};
#    $gunzip_ok = 0;
#
#    eval {
#	require IO::Uncompress::Gunzip;
#	$gunzip_ok++;
#    };
#
#    return $gunzip_ok;
#}
#
#sub inflate_ok {
#    return $inflate_ok if defined $inflate_ok;
#
#    local $@;
#    local $SIG{__DIE__};
#    $inflate_ok = 0;
#
#    eval {
#	require Compress::Raw::Zlib;
#	$inflate_ok++;
#    };
#
#    return $inflate_ok;
#}
#
#} 
#
#1;
### Net/HTTP/NB.pm ###
#package Net::HTTP::NB;
#
#use strict;
#use vars qw($VERSION @ISA);
#
#$VERSION = "6.09";
#$VERSION = eval $VERSION;
#
#require Net::HTTP;
#@ISA=qw(Net::HTTP);
#
#sub can_read {
#    return 1;
#}
#
#sub sysread {
#    my $self = $_[0];
#    if (${*$self}{'httpnb_read_count'}++) {
#	${*$self}{'http_buf'} = ${*$self}{'httpnb_save'};
#	die "Multi-read\n";
#    }
#    my $buf;
#    my $offset = $_[3] || 0;
#    my $n = sysread($self, $_[1], $_[2], $offset);
#    ${*$self}{'httpnb_save'} .= substr($_[1], $offset);
#    return $n;
#}
#
#sub read_response_headers {
#    my $self = shift;
#    ${*$self}{'httpnb_read_count'} = 0;
#    ${*$self}{'httpnb_save'} = ${*$self}{'http_buf'};
#    my @h = eval { $self->SUPER::read_response_headers(@_) };
#    if ($@) {
#	return if $@ eq "Multi-read\n";
#	die;
#    }
#    return @h;
#}
#
#sub read_entity_body {
#    my $self = shift;
#    ${*$self}{'httpnb_read_count'} = 0;
#    ${*$self}{'httpnb_save'} = ${*$self}{'http_buf'};
#    my $n = eval { $self->SUPER::read_entity_body(@_); };
#    if ($@) {
#	$_[0] = "";
#	return -1;
#    }
#    return $n;
#}
#
#1;
#
#__END__
#
### Net/HTTPS.pm ###
#package Net::HTTPS;
#
#use strict;
#use vars qw($VERSION $SSL_SOCKET_CLASS @ISA);
#
#$VERSION = "6.09";
#$VERSION = eval $VERSION;
#
#if ($SSL_SOCKET_CLASS) {
#}
#elsif ($SSL_SOCKET_CLASS = $ENV{PERL_NET_HTTPS_SSL_SOCKET_CLASS}) {
#    unless ($SSL_SOCKET_CLASS =~ /^(IO::Socket::SSL|Net::SSL)\z/) {
#	die "Bad socket class [$SSL_SOCKET_CLASS]";
#    }
#    eval "require $SSL_SOCKET_CLASS";
#    die $@ if $@;
#}
#elsif ($IO::Socket::SSL::VERSION) {
#    $SSL_SOCKET_CLASS = "IO::Socket::SSL"; 
#}
#elsif ($Net::SSL::VERSION) {
#    $SSL_SOCKET_CLASS = "Net::SSL";
#}
#else {
#    eval { require IO::Socket::SSL; };
#    if ($@) {
#	my $old_errsv = $@;
#	eval {
#	    require Net::SSL;  
#	};
#	if ($@) {
#	    $old_errsv =~ s/\s\(\@INC contains:.*\)/)/g;
#	    die $old_errsv . $@;
#	}
#	$SSL_SOCKET_CLASS = "Net::SSL";
#    }
#    else {
#	$SSL_SOCKET_CLASS = "IO::Socket::SSL";
#    }
#}
#
#require Net::HTTP::Methods;
#
#@ISA=($SSL_SOCKET_CLASS, 'Net::HTTP::Methods');
#
#sub configure {
#    my($self, $cnf) = @_;
#    $self->http_configure($cnf);
#}
#
#sub http_connect {
#    my($self, $cnf) = @_;
#    if ($self->isa("Net::SSL")) {
#	if ($cnf->{SSL_verify_mode}) {
#	    if (my $f = $cnf->{SSL_ca_file}) {
#		$ENV{HTTPS_CA_FILE} = $f;
#	    }
#	    if (my $f = $cnf->{SSL_ca_path}) {
#		$ENV{HTTPS_CA_DIR} = $f;
#	    }
#	}
#	if ($cnf->{SSL_verifycn_scheme}) {
#	    $@ = "Net::SSL from Crypt-SSLeay can't verify hostnames; either install IO::Socket::SSL or turn off verification by setting the PERL_LWP_SSL_VERIFY_HOSTNAME environment variable to 0";
#	    return undef;
#	}
#    }
#    $self->SUPER::configure($cnf);
#}
#
#sub http_default_port {
#    443;
#}
#
#if ($SSL_SOCKET_CLASS eq "Net::SSL") {
#    *blocking = sub { };
#}
#
#1;
#
### Nodejs/Util.pm ###
#package Nodejs::Util;
#
#our $DATE = '2016-07-03'; 
#our $VERSION = '0.006'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(
#                       get_nodejs_path
#                       nodejs_available
#                       system_nodejs
#               );
#
#our %SPEC;
#
#my %arg_all = (
#    all => {
#        schema => 'bool',
#        summary => 'Find all node.js instead of the first found',
#        description => <<'_',
#
#If this option is set to true, will return an array of paths intead of path.
#
#_
#    },
#);
#
#$SPEC{get_nodejs_path} = {
#    v => 1.1,
#    summary => 'Check the availability of Node.js executable in PATH',
#    description => <<'_',
#
#Return the path to executable or undef if none is available. Node.js is usually
#installed as 'node' or 'nodejs'.
#
#_
#    args => {
#        %arg_all,
#    },
#    result_naked => 1,
#};
#sub get_nodejs_path {
#    require File::Which;
#    require IPC::System::Options;
#
#    my %args = @_;
#
#    my @paths;
#    for my $name (qw/nodejs node/) {
#        my $path = File::Which::which($name);
#        next unless $path;
#
#        my $out = IPC::System::Options::readpipe(
#            $path, '-e', 'console.log(1+1)');
#        if ($out =~ /\A2\n?\z/) {
#            return $path unless $args{all};
#            push @paths, $path;
#        } else {
#        }
#    }
#    return undef unless @paths;
#    \@paths;
#}
#
#$SPEC{nodejs_available} = {
#    v => 1.1,
#    summary => 'Check the availability of Node.js',
#    description => <<'_',
#
#This is a more advanced alternative to `get_nodejs_path()`. Will check for
#`node` or `nodejs` in the PATH, like `get_nodejs_path()`. But you can also
#specify minimum version (and other options in the future). And it will return
#more details.
#
#Will return status 200 if everything is okay. Actual result will return the path
#to executable, and result metadata will contain extra result like detected
#version in `func.version`.
#
#Will return satus 412 if something is wrong. The return message will tell the
#reason.
#
#_
#    args => {
#        min_version => {
#            schema => 'str*',
#        },
#        path => {
#            summary => 'Search this instead of PATH environment variable',
#            schema => ['str*'],
#        },
#        %arg_all,
#    },
#};
#sub nodejs_available {
#    require IPC::System::Options;
#
#    my %args = @_;
#    my $all = $args{all};
#
#    my $paths = do {
#        local $ENV{PATH} = $args{path} if defined $args{path};
#        get_nodejs_path(all => 1);
#    };
#    defined $paths or return [412, "node.js not detected in PATH"];
#
#    my $res = [200, "OK"];
#    my @filtered_paths;
#    my @versions;
#    my @errors;
#
#    for my $path (@$paths) {
#        my $v;
#        if ($args{min_version}) {
#            my $out = IPC::System::Options::readpipe(
#                $path, '-v');
#            $out =~ /^(v\d+\.\d+\.\d+)$/ or do {
#                push @errors, "Can't recognize output of $path -v: $out";
#                next;
#            };
#            $v = version->parse($1);
#            $v >= version->parse($args{min_version}) or do {
#                push @errors, "Version of $path less than $args{min_version}";
#                next;
#            };
#        }
#        push @filtered_paths, $path;
#        push @versions, defined($v) ? "$v" : undef;
#    }
#
#    $res->[2]                 = $all ? \@filtered_paths : $filtered_paths[0];
#    $res->[3]{'func.path'}    = $all ? \@filtered_paths : $filtered_paths[0];
#    $res->[3]{'func.version'} = $all ? \@versions       : $versions[0];
#    $res->[3]{'func.errors'}  = \@errors;
#
#    unless (@filtered_paths) {
#        $res->[0] = 412;
#        $res->[1] = @errors == 1 ? $errors[0] :
#            "No eligible node.js found in PATH";
#    }
#
#    $res;
#}
#
#sub system_nodejs {
#    require IPC::System::Options;
#    my $opts = ref($_[0]) eq 'HASH' ? shift : {};
#
#    my $harmony_scoping = delete $opts->{harmony_scoping};
#    my $path = delete $opts->{path};
#
#    my %detect_nodejs_args;
#    if ($harmony_scoping) {
#        $detect_nodejs_args{min_version} = '0.5.10';
#    }
#    if ($path) {
#        $detect_nodejs_args{path} = $path;
#    }
#    my $detect_res = nodejs_available(%detect_nodejs_args);
#    die "No eligible node.js binary available: ".
#        "$detect_res->[0] - $detect_res->[1]" unless $detect_res->[0] == 200;
#
#    my @extra_args;
#    if ($harmony_scoping) {
#        my $node_v = $detect_res->[3]{'func.version'};
#        if (version->parse($node_v) < version->parse("2.0.0")) {
#            push @extra_args, "--use_strict", "--harmony_scoping";
#        } else {
#            push @extra_args, "--use_strict";
#        }
#    }
#
#    IPC::System::Options::system(
#        $opts,
#        $detect_res->[2],
#        @extra_args,
#        @_,
#    );
#}
#
#1;
#
#__END__
#
### PERLANCAR/Module/List.pm ###
#package PERLANCAR::Module::List;
#
#our $DATE = '2016-03-17'; 
#our $VERSION = '0.003005'; 
#
#
#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_]+/;
#	}
#	die "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 $return_path = $options->{return_path};
#	my $all = $options->{all};
#	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 = join("/", $incdir, @dir_suffix);
#			opendir(my $dh, $dir) or next;
#			while(defined(my $entry = readdir($dh))) {
#				if(($list_modules && $entry =~ $pm_rx) ||
#						($list_pod &&
#							$entry =~ $pod_rx)) {
#                                            $results{$prefix.$1} = $return_path ? ($all ? [@{ $results{$prefix.$1} || [] }, "$dir/$entry"] : "$dir/$entry") : undef
#						if $all && $return_path || !exists($results{$prefix.$1});
#				} elsif(($list_prefixes || $recurse) &&
#						($entry ne '.' && $entry ne '..') &&
#						$entry =~ $dir_rx &&
#						-d join("/", $dir,
#							$entry)) {
#					my $newpfx = $prefix.$entry."::";
#					next if exists $seen_prefixes{$newpfx};
#					$results{$newpfx} = $return_path ? ($all ? [@{ $results{$newpfx} || [] }, "$dir/$entry/"] : "$dir/$entry/") : undef
#						if ($all && $return_path || !exists($results{$newpfx})) && $list_prefixes;
#					push @prefixes, $newpfx if $recurse;
#				}
#			}
#			next unless $list_pod && $use_pod_dir;
#			$dir = join("/", $dir, "pod");
#			opendir($dh, $dir) or next;
#			while(defined(my $entry = readdir($dh))) {
#				if($entry =~ $pod_rx) {
#					$results{$prefix.$1} = $return_path ? ($all ? [@{ $results{$prefix.$1} || [] }, "$dir/$entry"] : "$dir/$entry") : undef;
#				}
#			}
#		}
#	}
#	return \%results;
#}
#
#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/Validate.pm ###
#package Params::Validate;
#
#use 5.008001;
#
#use strict;
#use warnings;
#
#our $VERSION = '1.24';
#
#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.24';
#
#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.24';
#
#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::croak( $_[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 = '(unknown)' 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.24';
#
#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 = '2016-06-14'; 
#our $VERSION = '0.03'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Exporter qw(import);
#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-12-17'; 
#our $VERSION = '0.44'; 
#
#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 = '2016-03-16'; 
#our $VERSION = '0.23'; 
#
#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::MaybeXS;
#        JSON::MaybeXS->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 = '2016-09-25'; 
#our $VERSION = '0.14'; 
#
#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);
#            if ($action eq 'meta') {
#                $meta->{_orig_args_as} = $meta->{args_as};
#                $meta->{args_as} = 'hash';
#                $meta->{_orig_result_naked} = $meta->{result_naked};
#                $meta->{result_naked} = 0;
#                return [200, "OK ($action)", $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 = '2016-06-10'; 
#our $VERSION = '0.87'; 
#
#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 = '2016-06-10'; 
#our $VERSION = '0.87'; 
#
#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_0-9][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->{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};
#        $req->{-orig_meta} = $self->{_orig_meta_cache}{$name}
#            if $self->{_orig_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->{_orig_args_as} = $meta->{args_as};
#        $meta->{args_as} = 'hash';
#        $meta->{_orig_result_naked} = $meta->{result_naked};
#        $meta->{result_naked} = 0;
#        my $sfp = $self->{set_function_properties};
#        if ($sfp) {
#            for (keys %$sfp) {
#                $meta->{"_orig_$_"} = $meta->{$_};
#                $meta->{$_} = $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 $sfp = $self->{set_function_properties};
#
#        my $wrapres = Perinci::Sub::Wrapper::wrap_sub(
#            sub_name=>$name, meta=>$meta,
#            convert=>{args_as=>'hash', result_naked=>0,
#                      ($sfp ? %$sfp : ())
#                  });
#        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 $newmeta = $wrapres->[2]{meta};
#            $newmeta->{_orig_result_naked} = $meta->{result_naked};
#            $newmeta->{_orig_args_as}      = $meta->{args_as};
#            if ($sfp) {
#                for (keys %$sfp) {
#                    $newmeta->{"_orig_$_"} = $meta->{$_};
#                }
#            }
#            __inject_entity_v_date($req, $newmeta);
#            $self->{_meta_cache}{$name} = $newmeta;
#        }
#    }
#
#    $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 = '2016-10-07'; 
#our $VERSION = '0.22'; 
#
#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::MaybeXS;
#    state $json = JSON::MaybeXS->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 = '2017-01-16'; 
#our $VERSION = '1.72'; 
#
#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 auto_abbrev_subcommand => (is=>'rw', default=>1);
#has description => (is=>'rw');
#has exit => (is=>'rw', default=>1);
#has formats => (is=>'rw');
#has default_format => (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 use_cleanser => (is=>'rw', default=>1);
#
#has extra_urls_for_version => (is=>'rw');
#
#has skip_format => (is=>'rw');
#
#has use_utf8 => (
#    is=>'rw',
#    default => sub {
#        $ENV{UTF8} // 0;
#    },
#);
#
#has default_dry_run => (
#    is=>'rw',
#    default => 0,
#);
#
#
#
#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);
#
#                $cmdline->_read_config($r) unless $r->{config};
#            }
#
#            return [] unless $r->{config};
#
#            my @profiles;
#            for my $section (keys %{$r->{config}}) {
#                my %keyvals;
#                for my $word (split /\s+/, ($section eq 'GLOBAL' ? '' : $section)) {
#                    if ($word =~ /(.+)=(.*)/) {
#                        $keyvals{$1} = $2;
#                    } else {
#                        $keyvals{subcommand} = $word;
#                    }
#                }
#                if (defined(my $p = $keyvals{profile})) {
#                    push @profiles, $p unless grep {$_ eq $p} @profiles;
#                }
#            }
#
#            require Complete::Util;
#            Complete::Util::complete_array_elem(
#                array=>\@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;
#        $_ = "_$_" if /\A\d/;
#    }
#    "${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') {
#        ($words, undef) = @{ Complete::Base::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::Bash;
#        ($words, undef) = @{ Complete::Bash::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;
#        require Encode;
#        ($words, $cword) = @{ Complete::Bash::parse_cmdline(undef, undef, {truncate_current_word=>1}) };
#        ($words, $cword) = @{ Complete::Bash::join_wordbreak_words($words, $cword) };
#        $words = [map {Encode::decode('UTF-8', $_)} @$words];
#    } elsif ($r->{shell} eq 'fish') {
#        require Complete::Bash;
#        ($words, $cword) = @{ Complete::Bash::parse_cmdline() };
#    } elsif ($r->{shell} eq 'tcsh') {
#        require Complete::Tcsh;
#        ($words, $cword) = @{ Complete::Tcsh::parse_cmdline() };
#    } elsif ($r->{shell} eq 'zsh') {
#        require Complete::Bash;
#        ($words, $cword) = @{ Complete::Bash::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') {
#        require Complete::Bash;
#        $formatted = Complete::Bash::format_completion(
#            $compres, {word=>$words->[$cword]});
#    } elsif ($r->{shell} eq 'fish') {
#        require Complete::Fish;
#        $formatted = Complete::Fish::format_completion($compres);
#    } elsif ($r->{shell} eq 'tcsh') {
#        require Complete::Tcsh;
#        $formatted = Complete::Tcsh::format_completion($compres);
#    } elsif ($r->{shell} eq 'zsh') {
#        require Complete::Zsh;
#        $formatted = Complete::Zsh::format_completion($compres);
#    }
#
#    $self->use_utf8(1);
#
#    [200, "OK", $formatted,
#     {
#         "func.words" => $words,
#         "func.cword" => $cword,
#         "cmdline.skip_format" => 1,
#     }];
#}
#
#sub _read_config {
#    require Perinci::CmdLine::Util::Config;
#
#    my ($self, $r) = @_;
#
#    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'};
#    $r->{_config_section_read_order} = $res->[3]{'func.section_read_order'}; 
#}
#
#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', 'no_auto_abbrev',
#            'no_getopt_compat', 'gnu_compat', 'bundling');
#        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 $scs = $self->list_subcommands;
#                    if ($self->auto_abbrev_subcommand) {
#                        my $num_matches = 0;
#                        my $complete_scn;
#                        for (keys %$scs) {
#                            if (index($_, $scn) == 0) {
#                                $num_matches++;
#                                $complete_scn = $_;
#                                last if $num_matches > 1;
#                            }
#                        }
#                        if ($num_matches == 1) {
#                            $scn = $complete_scn;
#                            $scd = $self->get_subcommand_data($scn);
#                            goto L1;
#                        }
#                    }
#                    my @similar =
#                        __find_similar_strings($scn, [keys %$scs]);
#                    my $suggestion = '';
#                    $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,
#            };
#        }
#      L1:
#        $r->{subcommand_name} = $scn;
#        $r->{subcommand_name_from} = $scn_from;
#        $r->{subcommand_data} = $scd;
#    }
#
#    $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,
#                program_name       => $self->program_name,
#                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?|stdin_or_args)\z/) {
#                    die "BUG: stream argument '$ak' needs to have cmdline_src ".
#                        "set to stdin, file, stdin_or_file, stdin_or_files, or stdin_or_args";
#                }
#            }
#        }
#
#        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} // '';
#
#                $src = '' if $src eq 'stdin_or_args' && -t STDIN;
#
#                if ($src && $as->{req}) {
#                    return 1;
#                } else {
#                    return 0;
#                }
#            },
#        );
#
#        return $ga_res unless $ga_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, $argspec, $argname) = @_;
#    my $schema = $argspec->{schema};
#    $schema = $schema->[1]{of} if $schema->[0] eq 'array';
#    my $type = Data::Sah::Util::Type::get_type($schema);
#
#    if (Data::Sah::Util::Type::is_simple($schema)) {
#        my $chomp = $type eq 'buf' ? 0 :
#            $argspec->{'cmdline.chomp'} // 1;
#        return sub {
#            local $/ = \(64*1024) if $type eq 'buf';
#
#            state $eof;
#            return undef if $eof;
#            my $l = <$fh>;
#            unless (defined $l) {
#                $eof++; return undef;
#            }
#            chomp($l) if $chomp;
#            $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?|stdin_or_args)/ ? -1 :
#                    $csb eq 'stdin_line' && $csa =~ /^(stdin|stdin_or_files?|stdin_or_args)/ ? 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_or_args|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?|stdin_or_args)\z/) {
#                    die [531, "Only one argument can be specified ".
#                             "cmdline_src stdin/stdin_or_file/stdin_or_files/stdin_or_args"]
#                        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, $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, $an) :
#                            $is_ary ? [<>] :
#                                do {local $/; ~~<>};
#                    $r->{args}{"-cmdline_src_$an"} = $src;
#                } elsif ($src eq 'stdin_or_args' && !(-t STDIN)) {
#                    unless (defined($r->{args}{$an})) {
#                        $r->{args}{$an} = $do_stream ?
#                            __gen_iter(\*STDIN, $as, $an) :
#                            $is_ary ? [map {chomp;$_} <STDIN>] :
#                                do {local $/; ~~<STDIN>};
#                    }
#                } 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, $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;
#  SELECT_HANDLE:
#    {
#        if ($ENV{VIEW_RESULT} // $resmeta->{"cmdline.view_result"}) {
#            my $viewer = $resmeta->{"cmdline.viewer"} // $ENV{VIEWER} //
#                $ENV{BROWSER};
#            last if defined $viewer && !$viewer; 
#            die [500, "No VIEWER program set"] unless defined $viewer;
#            $r->{viewer} = $viewer;
#            require File::Temp;
#            my $filename;
#            ($handle, $filename) = File::Temp::tempfile();
#            $r->{viewer_temp_path} = $filename;
#        }
#
#        if ($ENV{PAGE_RESULT} // $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;
#                if ($self->use_cleanser) {
#                    while (defined(my $rec = $x->())) {
#                        print $json->encode(
#                            $self->cleanser->clone_and_clean($rec)), "\n";
#                    }
#                } else {
#                    while (defined(my $rec = $x->())) {
#                        print $json->encode($rec), "\n";
#                    }
#                }
#            }
#        } else {
#            die "Result is a stream but no coderef provided";
#        }
#    } else {
#        print $handle $fres;
#        if ($r->{viewer}) {
#            require ShellQuote::Any::Tiny;
#            my $cmd = $r->{viewer} ." ". ShellQuote::Any::Tiny::shell_quote($r->{viewer_temp_path});
#            system $cmd;
#        }
#    }
#}
#
#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};
#
#    {
#        last if (-t STDOUT) || $r->{format};
#        last unless eval { require Pipe::Find; 1 };
#        my $pipeinfo = Pipe::Find::get_stdout_pipe_process();
#        last unless $pipeinfo;
#        last unless $pipeinfo->{exe} =~ m![/\\]td\z! ||
#            $pipeinfo->{cmdline} =~ m!\A([^\0]*[/\\])?perl\0([^\0]*[/\\])?td\0!;
#        $r->{format} = 'json';
#    }
#
#    $r->{format} //= $self->default_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::) {
#                no warnings 'once';
#                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:
#    my $is_success = $r->{res}[0] =~ /\A2/ || $r->{res}[0] == 304;
#    if ($is_success &&
#            ($self->skip_format ||
#             $r->{meta}{'cmdline.skip_format'} ||
#             $r->{res}[3]{'cmdline.skip_format'})) {
#        $r->{fres} = $r->{res}[2] // '';
#    } elsif ($is_success &&
#                 ($r->{res}[3]{stream} // $r->{meta}{result}{stream})) {
#    }else {
#        $log->tracef("[pericmd] Running hook_format_result ...");
#        $r->{res}[3]{stream} = 0;
#        $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 = '2016-12-15'; 
#our $VERSION = '1.73'; 
#
#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::MaybeXS;
#    state $json = do { JSON::MaybeXS->new->allow_nonref };
#    $json->decode(shift);
#}
#
#sub __json_encode {
#    require JSON::MaybeXS;
#    state $json = do { JSON::MaybeXS->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) = @_;
#
#    my $metao = risub($r->{meta});
#    if ($metao->can_dry_run) {
#        my $default_dry_run = $metao->default_dry_run // $self->default_dry_run;
#        $r->{dry_run} = 1 if $default_dry_run;
#        $r->{dry_run} = ($ENV{DRY_RUN} ? 1:0) if defined $ENV{DRY_RUN};
#        $self->common_opts->{dry_run} = {
#            getopt  => $default_dry_run ? 'dry-run!' : 'dry-run',
#            summary => $default_dry_run ?
#                N__("Disable simulation mode (also via DRY_RUN=0)") :
#                N__("Run in simulation mode (also via DRY_RUN=1)"),
#            handler => sub {
#                my ($go, $val, $r) = @_;
#                if ($val) {
#                    $log->debugf("[pericmd] Dry-run mode is activated");
#                    $r->{dry_run} = 1;
#                } else {
#                    $log->debugf("[pericmd] Dry-run mode is deactivated");
#                    $r->{dry_run} = 0;
#                }
#            },
#        };
#    }
#}
#
#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 $resmeta = $res->[3] // {};
#
#    my $handle = $r->{output_handle};
#
#    if ($ENV{COMP_LINE} || $res->[3]{"cmdline.skip_format"}) {
#        print $handle $res->[2];
#        return;
#    }
#
#    my $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;
#    }
#    binmode($handle, ":utf8") if $utf8;
#
#    $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 = '2016-12-15'; 
#our $VERSION = '1.73'; 
#
#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 = '2016-12-15'; 
#our $VERSION = '1.73'; 
#
#
#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 = '2017-01-27'; 
#our $VERSION = '0.14'; 
#
#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 {
#    no warnings 'once';
#    require Text::Wrap;
#
#    my %args = @_;
#
#    local $Text::Wrap::columns = $ENV{COLUMNS} // 80;
#
#    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) {
#            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, "\n" if $eg->{summary} && $i > 1;
#            if ($eg->{summary}) {
#                push @help, "  $eg->{summary}:\n";
#            } else {
#                push @help, "\n";
#            }
#            push @help, "  % $cmdline\n";
#        }
#    }
#
#    {
#        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};
#                next if grep {$_ eq 'hidden'} @{$arg_spec->{tags} // []};
#                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 = " (as base64-encoded str)";
#                } elsif ($ospec->{is_json}) {
#                    $add_sum = " (as JSON-encoded str)";
#                } elsif ($ospec->{is_yaml}) {
#                    $add_sum = " (as YAML-encoded str)";
#                }
#
#                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,
#                    Text::Wrap::wrap("", " " x (2+$len+2 +2),
#                                     $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 = '2017-01-16'; 
#our $VERSION = '1.72'; 
#
#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 csv html html+datatables/];
#
#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;
#    no warnings 'once';
#    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 equal2 {
#    state $require = do { require Scalar::Util };
#
#    my ($val1, $val2) = @_;
#
#
#    if (defined $val1) {
#        return 0 unless defined $val2;
#        if (ref $val1) {
#            return 0 unless ref $val2;
#            return Scalar::Util::refaddr($val1) eq Scalar::Util::refaddr($val2);
#        } else {
#            return 0 if ref $val2;
#            return $val1 eq $val2;
#        }
#    } else {
#        return 0 if defined $val2;
#        return 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+val',
#                    schema_is_normalized => 1,
#                });
#                $validators{"$schema"} = $v;
#            }
#            my $res = $validators{"$schema"}->($r->{args}{$arg});
#            if ($res->[0]) {
#                die [400, "Argument '$arg' fails validation: $res->[0]"];
#            }
#            my $val0 = $r->{args}{$arg};
#            my $coerced_val = $res->[1];
#            $r->{args}{$arg} = $coerced_val;
#            $r->{args}{"-orig_$arg"} = $val0 unless equal2($val0, $coerced_val);
#        }
#
#        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';
#
#    if ($fmt eq 'html+datatables') {
#        $fmt = 'text-pretty';
#        $ENV{VIEW_RESULT} //= 1;
#        $ENV{FORMAT_PRETTY_TABLE_BACKEND} //= 'Text::Table::HTML::DataTables';
#    }
#
#    my $fres = Perinci::Result::Format::Lite::format(
#        $r->{res}, $fmt, $r->{naked_res}, $self->{use_cleanser});
#
#    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) = @_;
#
#    my $res  = $r->{res};
#    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;
#        }
#        if ($r->{subcommand_data}) {
#            last if defined($utf8 = $r->{subcommand_data}{use_utf8});
#        }
#        $utf8 = $self->use_utf8;
#    }
#    binmode($handle, ":utf8") if $utf8;
#
#    $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;
#    my $metao = Perinci::Object::risub($r->{meta});
#    if ($metao->can_dry_run) {
#        my $default_dry_run = $metao->default_dry_run // $self->default_dry_run;
#        $r->{dry_run} = 1 if $default_dry_run;
#        $r->{dry_run} = ($ENV{DRY_RUN} ? 1:0) if defined $ENV{DRY_RUN};
#        $self->common_opts->{dry_run} = {
#            getopt  => $default_dry_run ? 'dry-run!' : 'dry-run',
#            summary => $default_dry_run ?
#                "Disable simulation mode (also via DRY_RUN=0)" :
#                "Run in simulation mode (also via DRY_RUN=1)",
#            handler => sub {
#                my ($go, $val, $r) = @_;
#                if ($val) {
#                    $log->debugf("[pericmd] Dry-run mode is activated");
#                    $r->{dry_run} = 1;
#                } else {
#                    $log->debugf("[pericmd] Dry-run mode is deactivated");
#                    $r->{dry_run} = 0;
#                }
#            },
#        };
#    }
#
#    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 = '2017-01-13'; 
#our $VERSION = '1.71'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#our %SPEC;
#
#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;
#        eval { @pw = getpwuid($>) };
#        return $pw[7] if @pw;
#    }
#    die "Can't get home directory";
#}
#
#$SPEC{get_default_config_dirs} = {
#    v => 1.1,
#    args => {},
#};
#sub get_default_config_dirs {
#    my @dirs;
#    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_filename => {},
#        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;
#
#    my @filenames;
#    my %section_config_filename_map;
#    if (my $names = $args{config_filename}) {
#        for my $name (ref($names) eq 'ARRAY' ? @$names : ($names)) {
#            if (ref($name) eq 'HASH') {
#                $section_config_filename_map{$name->{filename}} = $name->{section};
#                push @filenames, $name->{filename};
#            } else {
#                $section_config_filename_map{$name} = 'GLOBAL';
#                push @filenames, $name;
#            }
#        }
#    }
#    unless (@filenames) {
#        @filenames = (($args{program_name} // "prog") . ".conf");
#    }
#
#    if ($args{config_paths}) {
#        $paths = $args{config_paths};
#    } else {
#        for my $dir (@$config_dirs) {
#            for my $name (@filenames) {
#                my $path = "$dir/" . $name;
#                push @$paths, $path if -e $path;
#            }
#        }
#    }
#
#    my $reader = Config::IOD::Reader->new;
#    my %res;
#    my @read;
#    my %section_read_order;
#    for my $i (0..$#{$paths}) {
#        my $path           = $paths->[$i];
#        my $filename = $path; $filename =~ s!.*[/\\]!!;
#        my $wanted_section = $section_config_filename_map{$filename};
#        my $j = 0;
#        $section_read_order{GLOBAL} = [$i, $j++];
#        my $hoh = $reader->read_file(
#            $path,
#            sub {
#                my %args = @_;
#                return unless $args{event} eq 'section';
#                my $section = $args{section};
#                $section_read_order{$section} = [$i, $j++];
#            },
#        );
#        push @read, $path;
#        for my $section (keys %$hoh) {
#            my $hash = $hoh->{$section};
#
#            my $s = $section; $s =~ s/\s*\S*=.*\z//; 
#            $s = 'GLOBAL' if $s eq '';
#            next unless !defined($wanted_section) || $s eq $wanted_section;
#
#            for (keys %$hash) {
#                $res{$section}{$_} = $hash->{$_};
#            }
#        }
#    }
#    [200, "OK", \%res, {
#        'func.read_files' => \@read,
#        'func.section_read_order' => \%section_read_order,
#    }];
#}
#
#$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 $progn   = $fargs{program_name};
#    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 $csro = $r->{_config_section_read_order} // {};
#    my @sections = sort {
#        my $csro_a = $csro->{$a} // [0,0];
#        my $csro_b = $csro->{$b} // [0,0];
#        $csro_a->[0] <=> $csro_b->[0] ||
#            $csro_a->[1] <=> $csro_b->[1] ||
#            $a cmp $b
#        } keys %$conf;
#
#    my %seen_profiles; 
#    for my $section0 (@sections) {
#        my %keyvals;
#        my $sect_name;
#        for my $word (split /\s+/, $section0) {
#            if ($word =~ /(.*?)=(.*)/) {
#                $keyvals{$1} = $2;
#            } else {
#                $sect_name //= $word;
#            }
#        }
#        $seen_profiles{$keyvals{profile}}++ if defined $keyvals{profile};
#
#        my $sect_scn     = $keyvals{subcommand} // '';
#        my $sect_profile = $keyvals{profile};
#
#        if (length $scn) {
#            if (length($sect_scn) && $sect_scn ne $scn) {
#                next;
#            }
#        } else {
#            if (length $sect_scn) {
#                next;
#            }
#        }
#
#        if (defined $profile) {
#            if (defined($sect_profile) && $sect_profile ne $profile) {
#                next;
#            }
#            $found = 1 if defined($sect_profile) && $sect_profile eq $profile;
#        } else {
#            if (defined($sect_profile)) {
#                next;
#            }
#        }
#
#        if (defined($progn) && defined($keyvals{program})) {
#            if ($progn ne $keyvals{program}) {
#                next;
#            }
#        }
#
#        if (defined(my $env = $keyvals{env})) {
#            my ($var, $val);
#            if (($var, $val) = $env =~ /\A(\w+)=(.*)\z/) {
#                if (($ENV{$var} // '') ne $val) {
#                    next;
#                }
#            } elsif (($var, $val) = $env =~ /\A(\w+)!=(.*)\z/) {
#                if (($ENV{$var} // '') eq $val) {
#                    next;
#                }
#            } elsif (($var, $val) = $env =~ /\A(\w+)\*=(.*)\z/) {
#                if (index(($ENV{$var} // ''), $val) < 0) {
#                    next;
#                }
#            } else {
#                if (!$ENV{$env}) {
#                    next;
#                }
#            }
#        }
#
#
#        my $as = $meta->{args} // {};
#        for my $k (keys %{ $conf->{$section0} }) {
#            my $v = $conf->{$section0}{$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;
#            }
#        }
#    }
#
#    [200, "OK", $args, {'func.found'=>$found}];
#}
#
#1;
#
#__END__
#
### Perinci/Object.pm ###
#package Perinci::Object;
#
#our $DATE = '2016-12-28'; 
#our $VERSION = '0.29'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#require Exporter;
#our @ISA    = qw(Exporter);
#our @EXPORT = qw(rimeta risub rivar ripkg envres envresmulti envrestable
#                 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 envrestable {
#    require Perinci::Object::EnvResultTable;
#    Perinci::Object::EnvResultTable->new(@_);
#}
#
#sub riresmeta {
#    require Perinci::Object::ResMeta;
#    Perinci::Object::ResMeta->new(@_);
#}
#
#1;
#
#__END__
#
### Perinci/Object/EnvResult.pm ###
#package Perinci::Object::EnvResult;
#
#our $DATE = '2016-12-28'; 
#our $VERSION = '0.29'; 
#
#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 = '2016-12-28'; 
#our $VERSION = '0.29'; 
#
#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/EnvResultTable.pm ###
#package Perinci::Object::EnvResultTable;
#
#our $DATE = '2016-12-28'; 
#our $VERSION = '0.29'; 
#
#use 5.010;
#use strict;
#use warnings;
#
#use parent qw(Perinci::Object::EnvResult);
#
#sub add_field {
#    my ($self, $name, %attrs) = @_;
#    ${$self}->[3]{'table.fields'} //= [];
#    push @{ ${$self}->[3]{'table.fields'} }, $name;
#}
#
#1;
#
#__END__
#
### Perinci/Object/Function.pm ###
#package Perinci::Object::Function;
#
#our $DATE = '2016-12-28'; 
#our $VERSION = '0.29'; 
#
#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 default_dry_run {
#    my $self = shift;
#    my $ff = ${$self}->{features} // {};
#    ref($ff->{dry_run}) eq 'HASH' && $ff->{dry_run}{default};
#}
#
#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 = '2016-12-28'; 
#our $VERSION = '0.29'; 
#
#use 5.010;
#use strict;
#use warnings;
#
#sub __trim_blank_lines {
#    local $_ = shift;
#    return $_ unless defined;
#    s/\A(?:\n\s*)+//;
#    s/(?:\n\s*){2,}\z/\n/;
#    $_;
#}
#
#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 = '2016-12-28'; 
#our $VERSION = '0.29'; 
#
#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 = '2016-12-28'; 
#our $VERSION = '0.29'; 
#
#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 = '2016-12-28'; 
#our $VERSION = '0.29'; 
#
#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-11-29'; 
#our $VERSION = '0.45'; 
#
#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} // {};
#        my $tff = $res->[3]{'table.fields'};
#        if ($rfo->{$format}) {
#            $opts = $rfo->{$format};
#        } elsif ($rfo->{any}) {
#            $opts = $rfo->{any};
#        } elsif ($tff) {
#            $opts = {table_column_orders=>[$tff]};
#        }
#    } 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 = '2017-01-10'; 
#our $VERSION = '0.23'; 
#
#use 5.010001;
#
#use List::Util qw(first max);
#
#use Exporter qw(import);
#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 Cpanel::JSON::XS; 1 })   { Cpanel::JSON::XS->new->canonical(1)->convert_blessed->allow_nonref }
#        elsif (eval { require JSON::Tiny::Subclassable; 1 }) { JSON::Tiny::Subclassable->new }
#        elsif (eval { require JSON::PP; 1 })   { JSON::PP->new->canonical(1)->convert_blessed->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, $format) = @_;
#
#    $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;
#        my @map;
#        for (0..$#map0) {
#            $map[$_] = $map0[$_][0];
#        }
#        my $newdata = [];
#        for my $row (@$data) {
#            my @newrow;
#            for (0..$#map) { $newrow[$_] = $row->[$map[$_]] }
#            push @$newdata, \@newrow;
#        }
#        $data = $newdata;
#        my @newcolumns;
#        for (@map) { push @newcolumns, $columns[$_] }
#        @columns = @newcolumns;
#    }
#
#    my @field_idxs; 
#    {
#        my $tff = $resmeta->{'table.fields'} or last;
#        for my $i (0..$#columns) {
#            $field_idxs[$i] = firstidx { $_ eq $columns[$i] } @$tff;
#        }
#    }
#
#    {
#        last unless $header_row && @$data;
#        my $tff = $resmeta->{'table.fields'} or last;
#        my $tfu = $resmeta->{'table.field_units'} or last;
#        for my $i (0..$#columns) {
#            my $field_idx = $field_idxs[$i];
#            next unless $field_idx >= 0;
#            next unless defined $tfu->[$field_idx];
#            $data->[0][$i] .= " ($tfu->[$field_idx])";
#        }
#    }
#
#    {
#        my $tff   = $resmeta->{'table.fields'} or last;
#        my $tffmt = $resmeta->{'table.field_formats'} or last;
#
#        for my $ffmt (@$tffmt) {
#            next unless $ffmt;
#            if ($ffmt eq 'iso8601') {
#            }
#        }
#
#        for my $i (0..$#{$data}) {
#            my $row = $data->[$i];
#            for my $j (0..$#columns) {
#                next unless defined $row->[$j];
#                my $field_idx = $field_idxs[$j];
#                next unless $field_idx >= 0;
#                my $ffmt = $tffmt->[$field_idx];
#                next unless $ffmt;
#                if ($ffmt eq 'iso8601_datetime' || $ffmt eq 'iso8601_date') {
#                    if ($row->[$j] =~ /\A[0-9]+\z/) {
#                        my @t = gmtime($row->[$j]);
#                        if ($ffmt eq 'iso8601_datetime') {
#                            $row->[$j] = sprintf(
#                                "%04d-%02d-%02dT%02d:%02d:%02dZ",
#                                $t[5]+1900, $t[4]+1, $t[3], $t[2], $t[1], $t[0]);
#                        } else {
#                            $row->[$j] = sprintf(
#                                "%04d-%02d-%02d",
#                                $t[5]+1900, $t[4]+1, $t[3]);
#                        }
#                    }
#                } elsif ($ffmt eq 'boolstr') {
#                    $row->[$j] = $row->[$j] ? "yes" : "no";
#                } elsif ($ffmt eq 'sci2dec') {
#                    if ($row->[$j] =~ /\A(?:[+-]?)(?:\d+\.|\d*\.(\d+))[eE]([+-]?\d+)\z/) {
#                        my $n = length($1 || "") - $2; $n = 0 if $n < 0;
#                        $row->[$j] = sprintf("%.${n}f", $row->[$j]);
#                    }
#                }
#            }
#        }
#    }
#
#    if ($format eq 'text-pretty') {
#        {
#            no warnings 'uninitialized';
#            my $tfa = $resmeta->{'table.field_aligns'} or last;
#            last unless @$data;
#
#            for my $colidx (0..$#columns) {
#                my $field_idx = $field_idxs[$colidx];
#                next unless $field_idx >= 0;
#                my $align = $tfa->[$field_idx];
#                next unless $align;
#
#                my $maxw;
#                my ($maxw_bd, $maxw_d, $maxw_ad); 
#                if ($align eq 'number') {
#                    my (@w_bd, @w_d, @w_ad);
#                    for my $i (0..$#{$data}) {
#                        my $row = $data->[$i];
#                        if (@$row > $colidx) {
#                            my $cell = $row->[$colidx];
#                            if ($header_row && $i == 0) {
#                                my $w = length($cell);
#                                push @w_bd, 0;
#                                push @w_bd, 0;
#                                push @w_ad, 0;
#                            } elsif ($cell =~ /\A([+-]?\d+)(\.?)(\d*)\z/) {
#                                push @w_bd, length($1);
#                                push @w_d , length($2);
#                                push @w_ad, length($3);
#                            } elsif ($cell =~ /\A([+-]?\d+\.?\d*)([eE])([+-]?\d+)\z/) {
#                                push @w_bd, length($1);
#                                push @w_d , length($2);
#                                push @w_ad, length($3);
#                            } else {
#                                push @w_bd, length($cell);
#                                push @w_bd, 0;
#                                push @w_ad, 0;
#                            }
#                        } else {
#                            push @w_bd, 0;
#                            push @w_d , 0;
#                            push @w_ad, 0;
#                        }
#                    }
#                    $maxw_bd = max(@w_bd);
#                    $maxw_d  = max(@w_d);
#                    $maxw_ad = max(@w_ad);
#                    if ($header_row) {
#                        my $w = length($data->[0][$colidx]);
#                        if ($maxw_d == 0 && $maxw_ad == 0) {
#                            $maxw_bd = $w;
#                        }
#                    }
#                }
#
#                $maxw = max(map {
#                    @$_ > $colidx ? length($_->[$colidx]) : 0
#                } @$data);
#
#                for my $i (0..$#{$data}) {
#                    my $row = $data->[$i];
#                    for my $i (0..$#{$data}) {
#                        my $row = $data->[$i];
#                        next unless @$row > $colidx;
#                        my $cell = $row->[$colidx];
#                        next unless defined($cell);
#                        if ($align eq 'number') {
#                            my ($bd, $d, $ad);
#                            if ($header_row && $i == 0) {
#                            } elsif (($bd, $d, $ad) = $cell =~ /\A([+-]?\d+)(\.?)(\d*)\z/) {
#                                $cell = join(
#                                    '',
#                                    (' ' x ($maxw_bd - length($bd))), $bd,
#                                    $d , (' ' x ($maxw_d  - length($d ))),
#                                    $ad, (' ' x ($maxw_ad - length($ad))),
#                                );
#                            } elsif (($bd, $d, $ad) = $cell =~ /\A([+-]?\d+\.?\d*)([eE])([+-]?\d+)\z/) {
#                                $cell = join(
#                                    '',
#                                    (' ' x ($maxw_bd - length($bd))), $bd,
#                                    $d , (' ' x ($maxw_d  - length($d ))),
#                                    $ad, (' ' x ($maxw_ad - length($ad))),
#                                );
#                            }
#                            my $w = length($cell);
#                            $cell = (' ' x ($maxw - $w)) . $cell
#                                if $maxw > $w;
#                        } elsif ($align eq 'right') {
#                            $cell = (' ' x ($maxw - length($cell))) . $cell;
#                        } elsif ($align eq 'middle' || $align eq 'center') {
#                            my $w = length($cell);
#                            my $n = int(($maxw-$w)/2);
#                            $cell = (' ' x $n) . $cell . (' ' x ($maxw-$w-$n));
#                        } else {
#                            $cell .= (' ' x ($maxw - length($cell)));
#
#                        }
#                        $row->[$colidx] = $cell;
#                    }
#                }
#            } 
#        } 
#
#        my $fres;
#        if (my $backend = $ENV{FORMAT_PRETTY_TABLE_BACKEND}) {
#            require Text::Table::Any;
#            $fres = Text::Table::Any::table(rows=>$data, header_row=>$header_row, backend=>$backend);
#        } else {
#            require Text::Table::Tiny;
#            $fres = Text::Table::Tiny::table(rows=>$data, header_row=>$header_row);
#        }
#        $fres .= "\n" unless $fres =~ /\R\z/ || !length($fres);
#        $fres;
#    } elsif ($format eq 'csv') {
#        no warnings 'uninitialized';
#        join(
#            "",
#            map {
#                my $row = $_;
#                join(
#                    ",",
#                    map {
#                        my $cell = $_;
#                        $cell =~ s/(["\\])/\\$1/g;
#                        qq("$cell");
#                    } @$row)."\n";
#            } @$data
#        );
#    } elsif ($format eq 'html') {
#        no warnings 'uninitialized';
#        require HTML::Entities;
#
#        my $tfa = $resmeta->{'table.field_aligns'};
#
#        my @res;
#        push @res, "<table".($resmeta->{'table.html_class'} ?
#                                 " class=\"".HTML::Entities::encode_entities(
#                                     $resmeta->{'table.html_class'})."\"" : "").
#                                         ">\n";
#        for my $i (0..$#{$data}) {
#            my $data_elem = $i == 0 ? "th" : "td";
#            push @res, "<thead>\n" if $i == 0;
#            push @res, "<tbody>\n" if $i == 1;
#            push @res, " <tr>\n";
#            my $row = $data->[$i];
#            for my $j (0..$#{$row}) {
#                my $field_idx = $field_idxs[$j];
#                my $align;
#                if ($field_idx >= 0 && $tfa->[$field_idx]) {
#                    $align = $tfa->[$field_idx];
#                    $align = "right" if $align eq 'number';
#                    $align = "middle" if $align eq 'center';
#                }
#                push @res, "  <$data_elem",
#                    ($align ? " align=\"$align\"" : ""),
#                    ">", HTML::Entities::encode_entities($row->[$j]),
#                    "</$data_elem>\n";
#            }
#            push @res, " </tr>\n";
#            push @res, "</thead>\n" if $i == 0;
#        }
#        push @res, "</tbody>\n";
#        push @res, "</table>\n";
#        join '', @res;
#    } 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 =~ /\A(text|text-simple|text-pretty|csv|html)\z/) {
#        $format = $format eq 'text' ?
#            ((-t STDOUT) ? 'text-pretty' : 'text-simple') : $format;
#        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], $format);
#            } 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], $format);
#            } elsif (Data::Check::Structure::is_aohos($data, {max=>$max})) {
#                my @fieldnames;
#                if ($res->[3] && $res->[3]{'table.fields'} &&
#                        $res->[3]{'table.hide_unknown_fields'}) {
#                    @fieldnames = @{ $res->[3]{'table.fields'} };
#                } else {
#                    my %fieldnames;
#                    for my $row (@$data) {
#                        $fieldnames{$_}++ for keys %$row;
#                    }
#                    @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], $format);
#            } else {
#                $format = 'json-pretty';
#            }
#        }
#    }
#
#    my $tff = $res->[3]{'table.fields'};
#    $res = $res->[2] if $is_naked;
#
#    unless ($format =~ /\Ajson(-pretty)?\z/) {
#        warn "Unknown format '$format', fallback to json-pretty";
#        $format = 'json-pretty';
#    }
#    __cleanse($res) if ($cleanse//1);
#    if ($format =~ /json/) {
#        if ($tff && _json->can("sort_by") &&
#                eval { require Sort::ByExample; 1}) {
#            my $cmp = Sort::ByExample->cmp($tff);
#            _json->sort_by(sub { $cmp->($JSON::PP::a, $JSON::PP::b) });
#        }
#
#        if ($format eq 'json') {
#            return _json->encode($res) . "\n";
#        } else {
#            _json->pretty(1);
#            return _json->encode($res);
#        }
#    }
#}
#
#1;
#
#__END__
#
### Perinci/Sub/Complete.pm ###
#package Perinci::Sub::Complete;
#
#our $DATE = '2017-01-15'; 
#our $VERSION = '0.91'; 
#
#use 5.010001;
#use strict;
#use warnings;
#use Log::Any::IfLOG '$log';
#
#use Complete::Util qw(hashify_answer complete_array_elem complete_hash_key combine_answers modify_answer);
#use Complete::Common qw(:all);
#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_index
#                       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,
#        },
#    },
#};
#sub complete_from_schema {
#    my %args = @_;
#    my $sch  = $args{schema}; 
#    my $word = $args{word} // "";
#
#    my $fres;
#    $log->tracef("[comp][periscomp] entering complete_from_schema, word=<%s>, schema=%s", $word, $sch);
#
#    my ($type, $cs) = @{$sch};
#
#    unless ($type =~ /\A(all|any|array|bool|buf|cistr|code|date|duration|float|hash|int|num|obj|re|str|undef)\z/) {
#        no strict 'refs';
#        my $pkg = "Sah::SchemaR::$type";
#        (my $pkg_pm = "$pkg.pm") =~ s!::!/!g;
#        eval { require $pkg_pm; 1 };
#        goto RETURN_RES if $@;
#        my $rsch = ${"$pkg\::rschema"};
#        $type = $rsch->[0];
#        $cs = {};
#        for my $cs0 (@{ $rsch->[1] // [] }) {
#            for (keys %$cs0) {
#                $cs->{$_} = $cs0->{$_};
#            }
#        }
#        $log->tracef("[comp][periscomp] retrieving schema from module %s, base type=%s", $pkg, $type);
#    }
#
#    my $static;
#    my $words;
#    eval {
#        if (my $xcomp = $cs->{'x.completion'}) {
#            require Module::Installed::Tiny;
#            my $comp;
#            if (ref($xcomp) eq 'CODE') {
#                $comp = $xcomp;
#            } else {
#                my ($submod, $xcargs);
#                if (ref($xcomp) eq 'ARRAY') {
#                    $submod = $xcomp->[0];
#                    $xcargs = $xcomp->[1];
#                } else {
#                    $submod = $xcomp;
#                    $xcargs = {};
#                }
#                my $mod = "Perinci::Sub::XCompletion::$submod";
#                if (Module::Installed::Tiny::module_installed($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->(%$xcargs);
#                }
#            }
#            if ($comp) {
#                $log->tracef("[comp][periscomp] using arg completion routine from schema's 'x.completion' attribute");
#                $fres = $comp->(
#                    %{$args{extras} // {}},
#                    word=>$word, arg=>$args{arg}, args=>$args{args});
#                return; 
#                }
#            }
#
#        if ($cs->{is} && !ref($cs->{is})) {
#            $log->tracef("[comp][periscomp] adding completion from schema's 'is' clause");
#            push @$words, $cs->{is};
#            $static++;
#            return; 
#        }
#        if ($cs->{in}) {
#            $log->tracef("[comp][periscomp] adding completion from schema's '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,
#                        )
#                    } @{ $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 schema's '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 schema's '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 schema's '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 schema's '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 schema's '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 schema's '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),
#        {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)
#* `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
#<pm: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 => ''],
#        },
#        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`, 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 $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 arg spec's 'completion' property");
#                last GET_COMP_ROUTINE;
#            }
#            my $xcomp = $arg_spec->{'x.completion'};
#            if ($xcomp) {
#                if (ref($xcomp) eq 'CODE') {
#                    $comp = $xcomp;
#                } else {
#                    my ($submod, $xcargs);
#                    if (ref($xcomp) eq 'ARRAY') {
#                        $submod = $xcomp->[0];
#                        $xcargs = $xcomp->[1];
#                    } else {
#                        $submod = $xcomp;
#                        $xcargs = {};
#                    }
#                    my $mod = "Perinci::Sub::XCompletion::$submod";
#                    require Module::Installed::Tiny;
#                    if (Module::Installed::Tiny::module_installed($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->(%$xcargs);
#                    }
#                }
#                if ($comp) {
#                    $log->tracef("[comp][periscomp] using arg completion routine from arg spec's 'x.completion' attribute");
#                    last GET_COMP_ROUTINE;
#                }
#            }
#            my $ent = $arg_spec->{'x.schema.entity'};
#            if ($ent) {
#                require Module::Installed::Tiny;
#                my $mod = "Perinci::Sub::ArgEntity::$ent";
#                if (Module::Installed::Tiny::module_installed($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, 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);
#                $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},
#                );
#                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(arg=>$arg, extras=>$extras, schema=>$sch, word=>$word);
#    };
#    $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  => ['str*'],
#        },
#    },
#);
#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 $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) {
#                if (ref($xelcomp) eq 'CODE') {
#                    $elcomp = $xelcomp;
#                } else {
#                    my ($submod, $xcargs);
#                    if (ref($xelcomp) eq 'ARRAY') {
#                        $submod = $xelcomp->[0];
#                        $xcargs = $xelcomp->[1];
#                    } else {
#                        $submod = $xelcomp;
#                        $xcargs = {};
#                    }
#                    my $mod = "Perinci::Sub::XCompletion::$submod";
#                    require Module::Installed::Tiny;
#                    if (Module::Installed::Tiny::module_installed($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->(%$xcargs);
#                    }
#                }
#                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::Installed::Tiny;
#                my $mod = "Perinci::Sub::ArgEntity::$ent";
#                if (Module::Installed::Tiny::module_installed($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);
#                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);
#                $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,
#                     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 $nsch = Data::Sah::Normalize::normalize_schema($sch);
#
#        my ($type, $cs) = @$nsch;
#        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);
#    };
#    $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_arg_index} = {
#    v => 1.1,
#    summary => 'Given argument name and function metadata, complete arg element index',
#    description => <<'_',
#
#This is only relevant for arguments which have `index_completion` property set
#(currently only `hash` type arguments). When that property is not set, will
#simply return undef.
#
#Completion routine will get `%args`, with the following keys:
#
#* `word` (str, the word to be completed)
#* `arg` (str, the argument name which value is currently being completed)
#* `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
#<pm: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 => ''],
#        },
#        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`, 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_index {
#    require Data::Sah::Normalize;
#
#    my %args = @_;
#
#    my $fres;
#
#    $log->tracef("[comp][periscomp] entering complete_arg_index, arg=<%s>",
#                 $args{arg});
#
#    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;
#    };
#    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 $idxcomp;
#      GET_IDXCOMP_ROUTINE:
#        {
#            $idxcomp = $arg_spec->{index_completion};
#            if ($idxcomp) {
#                $log->tracef("[comp][periscomp] using arg element index completion routine from 'index_completion' property");
#                last GET_IDXCOMP_ROUTINE;
#            }
#        } 
#
#        if ($idxcomp) {
#            if (ref($idxcomp) eq 'CODE') {
#                $log->tracef("[comp][periscomp] invoking arg element index completion routine");
#                $fres = $idxcomp->(
#                    %$extras,
#                    %$ourextras,
#                    word=>$word);
#                return; 
#            } elsif (ref($idxcomp) eq 'ARRAY') {
#                $log->tracef("[comp][periscomp] using array specified in arg element index completion routine: %s", $idxcomp);
#                $fres = complete_array_elem(array=>$idxcomp, word=>$word);
#                $static = $word eq '';
#            }
#
#            $log->tracef("[comp][periscomp] arg spec's 'index_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_index request to Riap server");
#                my $res = $args{riap_client}->request(
#                    complete_arg_index => $args{riap_server_url},
#                    {(uri=>$args{riap_uri}) x !!defined($args{riap_uri}),
#                     arg=>$arg, args=>$args{args}, word=>$word},
#                );
#                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 $nsch = Data::Sah::Normalize::normalize_schema($sch);
#
#        my ($type, $cs) = @$nsch;
#        if ($type ne 'hash') {
#            $log->tracef("[comp][periscomp] can't complete element index for non-hash");
#            return; 
#        }
#
#        my %keys;
#        if ($cs->{keys}) {
#            $keys{$_}++ for keys %{ $cs->{keys} };
#        }
#        if ($cs->{indices}) {
#            $keys{$_}++ for keys %{ $cs->{indices} };
#        }
#        if ($cs->{req_keys}) {
#            $keys{$_}++ for @{ $cs->{req_keys} };
#        }
#        if ($cs->{allowed_keys}) {
#            $keys{$_}++ for @{ $cs->{allowed_keys} };
#        }
#
#        for (keys %{$args{args}{$arg} // {}}) {
#            delete $keys{$_};
#        }
#
#        $fres = complete_hash_key(word => $word, hash => \%keys);
#
#    }; 
#    $log->debug("[comp][periscomp] completion died: $@") if $@;
#    unless ($fres) {
#        $log->tracef("[comp][periscomp] no index 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_index, result=%s", $fres);
#    $fres;
#}
#
#$SPEC{complete_cli_arg} = {
#    v => 1.1,
#    summary => 'Complete command-line argument using Rinci function metadata',
#    description => <<'_',
#
#This routine uses <pm:Perinci::Sub::GetArgs::Argv> to generate <pm:Getopt::Long>
#specification from arguments list in Rinci function metadata and common options.
#Then, it will use <pm: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 <pm: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`, 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 <pm: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 <pm: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 $fres;
#
#        my %rargs = (
#            riap_server_url => $args{riap_server_url},
#            riap_uri        => $args{riap_uri},
#            riap_client     => $args{riap_client},
#        );
#
#        $extras->{parsed_opts} = $cargs{parsed_opts};
#
#        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;
#                } elsif ($ospec =~ /\%$/) {
#                    if ($word =~ /(.*?)=(.*)/s) {
#                        my $key = $1;
#                        my $val = $2;
#                        $fres = complete_arg_elem(
#                            meta=>$meta, arg=>$sm->{arg}, args=>$gares->[2],
#                            word=>$val, index=>$key,
#                            extras=>$extras, %rargs);
#                        modify_answer(answer=>$fres, prefix=>"$key=");
#                        goto RETURN_RES;
#                    } else {
#                        $fres = complete_arg_index(
#                            meta=>$meta, arg=>$sm->{arg}, args=>$gares->[2],
#                            word=>$word, extras=>$extras, %rargs);
#                        modify_answer(answer=>$fres, suffix=>"=");
#                        $fres->{path_sep} = "=";
#                        $fres->{esc_mode} = "none";
#                        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);
#                    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 = '2016-12-12'; 
#our $VERSION = '0.10'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Data::Sah::Util::Type qw(is_simple);
#
#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 my $arg (sort {$args_prop->{$a}{pos} <=> $args_prop->{$b}{pos}}
#                         grep {defined $args_prop->{$_}{pos}} keys %iargs) {
#            my $pos = $args_prop->{$arg}{pos};
#            if ($args_prop->{$arg}{greedy}) {
#                my $sch = $args_prop->{$arg}{schema};
#                my $is_array_of_simple = $sch && $sch->[0] eq 'array' &&
#                    is_simple($sch->[1]{of} // $sch->[1]{each_elem});
#                for my $el (@{ $iargs{$arg} }) {
#                    $argv[$pos] = $is_array_of_simple ? $el : _encode($el);
#                    $pos++;
#                }
#            } else {
#                $argv[$pos] = _encode($iargs{$arg});
#            }
#            delete $iargs{$arg};
#        }
#    }
#
#    for (sort keys %iargs) {
#        my $sch = $args_prop->{$_}{schema};
#        my $is_bool = $sch && $sch->[0] eq 'bool';
#        my $is_array_of_simple = $sch && $sch->[0] eq 'array' &&
#            $sch->[1]{of} && is_simple($sch->[1]{of});
#        my $is_hash_of_simple = $sch && $sch->[0] eq 'hash' &&
#            is_simple($sch->[1]{of} // $sch->[1]{each_value} // $sch->[1]{each_elem});
#        my $can_be_comma_separated = $is_array_of_simple &&
#            $sch->[1]{of}[0] =~ /\A(int|float)\z/; 
#        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";
#            }
#        } elsif ($can_be_comma_separated) {
#            push @argv, "$dashopt", join(",", @{ $iargs{$_} });
#        } elsif ($is_array_of_simple) {
#            for (@{ $iargs{$_} }) {
#                push @argv, "$dashopt", $_;
#            }
#        } elsif ($is_hash_of_simple) {
#            my $arg = $iargs{$_};
#            for (sort keys %$arg) {
#                push @argv, "$dashopt", "$_=$arg->{$_}";
#            }
#        } 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-12-29'; 
#our $VERSION = '0.08'; 
#
#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) {
#        next if $k =~ /\A-/; 
#        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 = '2016-12-15'; 
#our $VERSION = '0.80'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Data::Sah::Normalize qw(normalize_schema);
#use Data::Sah::Util::Type qw(is_type is_simple);
#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)',
#};
#
#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 _is_coercible_from_simple {
#    my $nsch = shift;
#    my $cset = $nsch->[1] or return 0;
#    my $rules = $cset->{'x.perl.coerce_rules'} // $cset->{'x.coerce_rules'}
#        or return 0;
#    for my $rule (@$rules) {
#        next unless $rule =~ /\A([^_]+)_/;
#        return 1 if is_simple($1);
#    }
#    0;
#}
#
#sub _is_simple_or_coercible_from_simple {
#    my $nsch = shift;
#    is_simple($nsch) || _is_coercible_from_simple($nsch);
#}
#
#sub _is_simple_or_array_of_simple_or_hash_of_simple {
#    my $nsch = shift;
#
#    my $is_simple = 0;
#    my $is_array_of_simple = 0;
#    my $is_hash_of_simple = 0;
#    my $eltype;
#
#    my $type = $nsch->[0];
#    my $cset = $nsch->[1];
#
#    {
#        unless (is_type($nsch)) {
#            require Data::Sah::Resolve;
#            my $res = Data::Sah::Resolve::resolve_schema(
#                {merge_clause_sets => 0}, $nsch);
#            $type = $res->[0];
#            $cset = $res->[1][0] // {};
#        }
#
#        $is_simple = _is_simple_or_coercible_from_simple([$type, $cset]);
#        last if $is_simple;
#
#        if ($type eq 'array') {
#            my $elnsch = $cset->{of} // $cset->{each_elem};
#            last unless $elnsch;
#            $elnsch = normalize_schema($elnsch);
#            $eltype = $elnsch->[0];
#
#            unless (is_type($elnsch)) {
#                require Data::Sah::Resolve;
#                my $res = Data::Sah::Resolve::resolve_schema(
#                    {merge_clause_sets => 0}, $elnsch);
#                $elnsch = [$res->[0], $res->[1][0] // {}]; 
#                $eltype = $res->[0];
#            }
#
#            $is_array_of_simple = _is_simple_or_coercible_from_simple($elnsch);
#            last;
#        }
#
#        if ($type eq 'hash') {
#            my $elnsch = $cset->{of} // $cset->{each_value} // $cset->{each_elem};
#            last unless $elnsch;
#            $elnsch = normalize_schema($elnsch);
#            $eltype = $elnsch->[0];
#
#            unless (is_type($elnsch)) {
#                require Data::Sah::Resolve;
#                my $res = Data::Sah::Resolve::resolve_schema(
#                    {merge_clause_sets => 0}, $elnsch);
#                $elnsch = [$res->[0], $res->[1][0] // {}]; 
#                $eltype = $res->[0];
#            }
#
#            $is_hash_of_simple = _is_simple_or_coercible_from_simple($elnsch);
#            last;
#        }
#    }
#
#    ($is_simple, $is_array_of_simple, $is_hash_of_simple, $type, $cset, $eltype);
#}
#
#sub _opt2ospec {
#    my ($opt, $schema, $arg_spec) = @_;
#    my ($is_simple, $is_array_of_simple, $is_hash_of_simple, $type, $cset, $eltype) =
#        _is_simple_or_array_of_simple_or_hash_of_simple($schema);
#
#    my (@opts, @types, @isaos, @ishos);
#
#    if ($is_array_of_simple || $is_hash_of_simple) {
#        my $singular_opt;
#        if ($arg_spec && $arg_spec->{'x.name.is_plural'}) {
#            if ($arg_spec->{'x.name.singular'}) {
#                $singular_opt = _arg2opt($arg_spec->{'x.name.singular'});
#            } else {
#                require Lingua::EN::PluralToSingular;
#                $singular_opt = Lingua::EN::PluralToSingular::to_singular($opt);
#            }
#        } else {
#            $singular_opt = $opt;
#        }
#        push @opts , $singular_opt;
#        push @types, $eltype;
#        push @isaos, $is_array_of_simple ? 1:0;
#        push @ishos, $is_hash_of_simple  ? 1:0;
#    }
#
#    if ($is_simple || !@opts) {
#        push @opts , $opt;
#        push @types, $type;
#        push @isaos, 0;
#        push @ishos, 0;
#    }
#
#    my @res;
#
#    for my $i (0..$#opts) {
#        my $opt   = $opts[$i];
#        my $type  = $types[$i];
#        my $isaos = $isaos[$i];
#        my $ishos = $ishos[$i];
#
#        if ($type eq 'bool') {
#            if (length($opt) == 1 || $cset->{is}) {
#                push @res, ($opt, {opts=>[$opt]}), undef;
#            } else {
#                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]};
#                }
#            }
#        } elsif ($type eq 'buf') {
#            push @res, (
#                "$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' : 's') .
#                ($isaos ? '@' : $ishos ? '%' : '');
#            push @res, ("$opt=$t", {opts=>[$opt], desttype=>"", type=>$t}, undef);
#        }
#    }
#
#    @res;
#}
#
#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};
#        next if grep { $_ eq 'hidden' || $_ eq 'hidden-cli' }
#            @{ $arg_spec->{tags} // [] };
#        my $sch      = $arg_spec->{schema} // ['any', {}];
#        my ($is_simple, $is_array_of_simple, $is_hash_of_simple, $type, $cset, $eltype) =
#            _is_simple_or_array_of_simple_or_hash_of_simple($sch);
#
#        if ($type eq 'array' && $cset->{of}) {
#            $cset->{of} = normalize_schema($cset->{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 $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_simple) {
#                $val_set = 1; $val = $_[1];
#                $rargs->{$arg} = $val;
#            } elsif ($is_array_of_simple) {
#                $rargs->{$arg} //= [];
#                $val_set = 1; $val = $_[1];
#                push @{ $rargs->{$arg} }, $val;
#            } elsif ($is_hash_of_simple) {
#                $rargs->{$arg} //= {};
#                $val_set = 1; $val = $_[2];
#                $rargs->{$arg}{$_[1]} = $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} && !$is_simple) {
#                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} && !$is_simple) {
#                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 <pm: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 <pm: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", "no_getopt_compat", "gnu_compat", "bundling");
#        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 ($is_simple, $is_array_of_simple, $is_hash_of_simple, $type, $cset, $eltype) =
#                    _is_simple_or_array_of_simple_or_hash_of_simple($arg_spec->{schema});
#
#                if ($arg_spec->{greedy} && ref($val) eq 'ARRAY' &&
#                        !$is_array_of_simple && !$is_hash_of_simple) {
#                    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) {
#                  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 = '2016-12-10'; 
#our $VERSION = '0.16'; 
#
#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;
#                    } elsif ($type eq 'hash') {
#                        $rargs->{$a} = {};
#                        for my $j (0..$#elems) {
#                            my $elem = $elems[$j];
#                            unless ($elem =~ /(.*?)=(.*)/) {
#                                return [400, "Invalid key=value pair in element #$j"];
#                            }
#                            $rargs->{$a}{$1} = $2;
#                        }
#                    } 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 = '2016-12-11'; 
#our $VERSION = '0.19'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#require Exporter;
#our @ISA = qw(Exporter);
#our @EXPORT_OK = qw(
#                       normalize_function_metadata
#               );
#
#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;
#
#    require Sah::Schema::rinci::function_meta;
#    my $sch = $Sah::Schema::rinci::function_meta::schema;
#    my $sch_proplist = $sch->[1]{_prop}
#        or die "BUG: Rinci schema structure changed (1a)";
#
#    _normalize($meta, 1.1, $opts, $sch_proplist, {}, '');
#}
#
#1;
#
#__END__
#
### Perinci/Sub/To/CLIDocData.pm ###
#package Perinci::Sub::To::CLIDocData;
#
#our $DATE = '2016-10-27'; 
#our $VERSION = '0.28'; 
#
#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(\d+)?:(.+)/) {
#            my $cat = ucfirst($2);
#            my $ordering = $1 // 50;
#            $cat =~ s/-/ /g;
#            $cat .= " " . $noun;
#            push @cats, [$cat, $ordering]; 
#        }
#    }
#    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 <pm: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 <pm: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->{greedy}) {
#                $arg = $arg_spec->{'x.name.singular'}
#                    if $arg_spec->{'x.name.is_plural'} &&
#                    defined $arg_spec->{'x.name.singular'};
#            }
#            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->{$_};
#                }
#
#                {
#                    local $arg_spec->{tags} = ['category0:main']
#                        if !$arg_spec->{tags} || !@{$arg_spec->{tags}};
#                    _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, use_pos => 1);
#                    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 = '2017-01-31'; 
#our $VERSION = '0.46'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#require Exporter;
#our @ISA = qw(Exporter);
#our @EXPORT_OK = qw(
#                       err
#                       caller
#                       warn_err
#                       die_err
#                       gen_modified_sub
#                       gen_curried_sub
#               );
#
#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 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]");
#}
#
#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}];
#}
#
#$SPEC{gen_curried_sub} = {
#    v => 1.1,
#    summary => 'Generate curried subroutine (and its metadata)',
#    description => <<'_',
#
#This is a more convenient helper than `gen_modified_sub` if you want to create a
#new subroutine that has some of its arguments preset (so they no longer need to
#be present in the new metadata).
#
#For more general needs of modifying a subroutine (e.g. add some arguments,
#modify some arguments, etc) use `gen_modified_sub`.
#
#_
#    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.
#
#_
#            req => 1,
#            pos => 0,
#        },
#        set_args => {
#            summary => 'Arguments to set',
#            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.
#
#_
#            req => 1,
#            pos => 2,
#        },
#    },
#    args_as => 'array',
#    result_naked => 1,
#};
#sub gen_curried_sub {
#    my ($base_name, $set_args, $output_name) = @_;
#
#    my $caller = CORE::caller();
#
#    my ($base_pkg, $base_leaf);
#    if ($base_name =~ /(.+)::(.+)/) {
#        ($base_pkg, $base_leaf) = ($1, $2);
#    } else {
#        $base_pkg  = $caller;
#        $base_leaf = $base_name;
#    }
#
#    my ($output_pkg, $output_leaf);
#    if ($output_name =~ /(.+)::(.+)/) {
#        ($output_pkg, $output_leaf) = ($1, $2);
#    } else {
#        $output_pkg  = $caller;
#        $output_leaf = $output_name;
#    }
#
#    my $base_sub = \&{"$base_pkg\::$base_leaf"};
#
#    my $res = gen_modified_sub(
#        base_name   => "$base_pkg\::$base_leaf",
#        output_name => "$output_pkg\::$output_leaf",
#        output_code => sub {
#            no strict 'refs';
#            $base_sub->(@_, %$set_args);
#        },
#        remove_args => [keys %$set_args],
#        install => 1,
#    );
#
#    die "Can't generate curried sub: $res->[0] - $res->[1]"
#        unless $res->[0] == 200;
#
#    1;
#}
#
#1;
#
#__END__
#
### Perinci/Sub/Util/Args.pm ###
#package Perinci::Sub::Util::Args;
#
#our $DATE = '2017-01-31'; 
#our $VERSION = '0.46'; 
#
#use 5.010001;
#use strict 'subs', 'vars';
#use warnings;
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(
#                       args_by_tag
#                       argnames_by_tag
#                       func_args_by_tag
#                       func_argnames_by_tag
#                       call_with_its_args
#);
#
#sub args_by_tag {
#    my ($meta, $args, $tag) = @_;
#
#    my @res;
#    my $args_prop = $meta->{args} or return ();
#    my $neg = $tag =~ s/\A!//;
#    for my $argname (keys %$args_prop) {
#        my $argspec = $args_prop->{$argname};
#        if ($neg) {
#            next unless !$argspec->{tags} ||
#                !(grep {$_ eq $tag} @{$argspec->{tags}});
#        } else {
#            next unless $argspec->{tags} &&
#                grep {$_ eq $tag} @{$argspec->{tags}};
#        }
#        push @res, $argname, $args->{$argname}
#            if exists $args->{$argname};
#    }
#    @res;
#}
#
#sub argnames_by_tag {
#    my ($meta, $tag) = @_;
#
#    my @res;
#    my $args_prop = $meta->{args} or return ();
#    my $neg = 1 if $tag =~ s/\A!//;
#    for my $argname (keys %$args_prop) {
#        my $argspec = $args_prop->{$argname};
#        if ($neg) {
#            next unless !$argspec->{tags} ||
#                !(grep {$_ eq $tag} @{$argspec->{tags}});
#        } else {
#            next unless $argspec->{tags} &&
#                grep {$_ eq $tag} @{$argspec->{tags}};
#        }
#        push @res, $argname;
#    }
#    sort @res;
#}
#
#sub _find_meta {
#    my $caller = shift;
#    my $func_name = shift;
#
#    if ($func_name =~ /(.+)::(.+)/) {
#        return ${"$1::SPEC"}{$2};
#    } else {
#        return ${"$caller->[0]::SPEC"}{$func_name};
#    }
#}
#
#sub func_args_by_tag {
#    my ($func_name, $args, $tag) = @_;
#    my $meta = _find_meta([caller(1)], $func_name)
#        or die "Can't find Rinci function metadata for $func_name";
#    args_by_tag($meta, $args, $tag);
#}
#
#sub func_argnames_by_tag {
#    my ($func_name, $tag) = @_;
#    my $meta = _find_meta([caller(1)], $func_name)
#        or die "Can't find Rinci function metadata for $func_name";
#    argnames_by_tag($meta, $tag);
#}
#
#sub call_with_its_args {
#    my ($func_name, $args) = @_;
#
#    my ($meta, $func);
#    if ($func_name =~ /(.+)::(.+)/) {
#        defined &{$func_name}
#            or die "Function $func_name not defined";
#        $func = \&{$func_name};
#        $meta = ${"$1::SPEC"}{$2};
#    } else {
#        my @caller = caller(1);
#        my $fullname = "$caller[0]::$func_name";
#        defined &{$fullname}
#            or die "Function $fullname not defined";
#        $func = \&{$fullname};
#        $meta = ${"$caller[0]::SPEC"}{$func_name};
#    }
#    $meta or die "Can't find Rinci function metadata for $func_name";
#
#    my @args;
#    if ($meta->{args}) {
#        for my $argname (keys %{ $meta->{args} }) {
#            push @args, $argname, $args->{$argname}
#                if exists $args->{$argname};
#        }
#    }
#    $func->(@args);
#}
#
#1;
#
#__END__
#
### Perinci/Sub/Util/ResObj.pm ###
#package Perinci::Sub::Util::ResObj;
#
#our $DATE = '2017-01-31'; 
#our $VERSION = '0.46'; 
#
#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 = '2017-01-31'; 
#our $VERSION = '0.46'; 
#
#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 = '2016-06-02'; 
#our $VERSION = '0.83'; 
#
#use 5.010001;
#use strict;
#use warnings;
#use experimental 'smartmatch';
#use Log::Any::IfLOG '$log';
#
#use Data::Dmp qw(dmp);
#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 _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 =~ /\A(use|no) (\S+)/) {
#            $self->_check_module($2);
#            $self->push_lines("$mod;");
#        } elsif ($mod =~ /\A\w+(::\w+)*\z/) {
#            $self->_check_module($mod);
#            $self->push_lines("require $mod;");
#        } else {
#            die "BUG: Invalid module name/statement: $mod";
#        }
#        push @{ $self->{_modules} }, $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 = ".dmp($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{'.dmp($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{'.dmp($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("use 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 || $_ ~~ '.dmp([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}) {
#                    die "Error in schema for argument '$argname': must be str/buf/array if stream=1"
#                        unless $sch->[0] =~ /\A(str|buf|array)\z/; 
#                    die "Error in schema for argument '$argname': must specify 'of' array clause if stream=1"
#                        if $sch->[0] eq 'array' && !$sch->[1]{of};
#
#                    $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               => $argspec->{stream} && $sch->[0] eq 'array' ? $sch->[1]{of} : $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} // {}},
#                );
#                die "Incompatible Data::Sah version (cd v=$cd->{v}, expected 2)" unless $cd->{v} == 2;
#                for my $mod_rec (@{ $cd->{modules} }) {
#                    next unless $mod_rec->{phase} eq 'runtime';
#                    $self->_add_module($mod_rec->{use_statement} // $mod_rec->{name});
#                }
#                $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'".' ($rec) 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 //= ".dmp($argspec->{default}).";");
#                } elsif ($has_sch_default) {
#                    $self->push_lines(
#                        '} else {',
#                        "    $argterm //= ".dmp($sch->[1]{default}).";");
#                }
#                $self->push_lines("} ## if exists arg $prefix$argname");
#            } 
#
#        } elsif ($has_default_prop) {
#            $self->push_lines("$argterm = ".dmp($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},
#    );
#    die "Incompatible Data::Sah version (cd v=$cd->{v}, expected 2)" unless $cd->{v} == 2;
#    for my $mod_rec (@{ $cd->{modules} }) {
#        next unless $mod_rec->{phase} eq 'runtime';
#        $self->_add_module($mod_rec->{use_statement} // $mod_rec->{name});
#    }
#    $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};
#            if ($v->{stream}) {
#                die "Error in result schema: must be str/buf/array if stream=1"
#                    unless $sch->[0] =~ /\A(str|buf|array)\z/; 
#                die "Error in result schema: must specify 'of' array clause if stream=1"
#                    if $sch->[0] eq 'array' && !$sch->[1]{of};
#            }
#            $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} // {}},
#            );
#            die "Incompatible Data::Sah version (cd v=$cd->{v}, expected 2)" unless $cd->{v} == 2;
#            for my $mod_rec (@{ $cd->{modules} }) {
#                next unless $mod_rec->{phase} eq 'runtime';
#                $self->_add_module($mod_rec->{use_statement} // $mod_rec->{name});
#            }
#            $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 (\$_w_res2) 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->[0] eq 'array' ? $sch->[1]{of} : $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} // {}},
#            );
#            die "Incompatible Data::Sah version (cd v=$cd->{v}, expected 2)" unless $cd->{v} == 2;
#            $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 ($rec) fails 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/ChildError.pm ###
#package Proc::ChildError;
#
#our $DATE = '2016-01-06'; 
#our $VERSION = '0.04'; 
#
#use strict;
#use warnings;
#
#require Exporter;
#our @ISA       = qw(Exporter);
#our @EXPORT_OK = qw(explain_child_error);
#
#sub explain_child_error {
#    my $opts;
#    if (ref($_[0]) eq 'HASH') {
#        $opts = shift;
#    } else {
#        $opts = {};
#    }
#
#    my ($num, $str);
#    if (defined $_[0]) {
#        $num = $_[0];
#        $str = $_[1];
#    } else {
#        $num = $?;
#        $str = $!;
#    }
#
#    my $prefix = "";
#    if (defined $opts->{prog}) {
#        $prefix = "$opts->{prog} ";
#    }
#
#    if ($num == -1) {
#        return "${prefix}failed to execute: ".($str ? "$str ":"")."($num)";
#    } elsif ($num & 127) {
#        return sprintf(
#            "${prefix}died with signal %d, %s coredump",
#            ($num & 127),
#            (($num & 128) ? 'with' : 'without'));
#    } else {
#        return sprintf("${prefix}exited with code %d", $num >> 8);
#    }
#}
#
#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 = '2016-03-11'; 
#our $VERSION = '0.22'; 
#
#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::Util;
#    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::Util::ta_trunc($msg, $bwidth);
#                $mwidth = Text::ANSI::Util::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::Util::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 = '2016-10-29'; 
#our $VERSION = '0.06'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use re qw(regexp_pattern);
#
#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->parse($plver) >= version->parse('5.14.0');
#    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__
#
### Role/Tiny.pm ###
#package Role::Tiny;
#
#sub _getglob { \*{$_[0]} }
#sub _getstash { \%{"$_[0]::"} }
#
#use strict;
#use warnings;
#
#our $VERSION = '2.000003';
#$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 croak {
#  require Carp;
#  no warnings 'redefine';
#  *croak = \&Carp::croak;
#  goto &Carp::croak;
#}
#
#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;
#  $me->_install_subs($target);
#  return if $me->is_role($target); 
#  $INFO{$target}{is_role} = 1;
#  my $stash = _getstash($target);
#  my @not_methods = (map { *$_{CODE}||() } grep !ref($_), values %$stash);
#  @{$INFO{$target}{not_methods}={}}{@not_methods} = @not_methods;
#  $APPLIED_TO{$target} = { $target => undef };
#  foreach my $hook (@ON_ROLE_CREATE) {
#    $hook->($target);
#  }
#}
#
#sub _install_subs {
#  my ($me, $target) = @_;
#  return if $me->is_role($target);
#  foreach my $type (qw(before after around)) {
#    *{_getglob "${target}::${type}"} = sub {
#      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;
#  };
#}
#
#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);
#
#  croak "This is apply_role_to_package" if ref($to);
#  croak "${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) = @_;
#  croak "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) = @_;
#
#  croak "No roles supplied!" unless @roles;
#
#  _load_module($superclass);
#  {
#    my %seen;
#    if (my @dupes = grep 1 == $seen{$_}++, @roles) {
#      croak "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);
#    croak "${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;
#    croak $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;
#    croak $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 {
#      croak "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) = @_;
#  croak "${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};
#  my $info = $INFO{$to};
#  my $existing = ($info ? $info->{modifiers} : $COMPOSED{modifiers}{$to}) ||= [];
#  my @modifiers = grep {
#    my $modifier = $_;
#    !grep $_ == $modifier, @$existing;
#  } @{$modifiers||[]};
#  push @$existing, @modifiers;
#
#  if (!$info) {
#    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 {
#      require Class::Method::Modifiers;
#      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} || $INFO{$role}{not_methods}));
#}
#
#1;
#__END__
#
### Role/Tiny/With.pm ###
#package Role::Tiny::With;
#
#use strict;
#use warnings;
#
#our $VERSION = '2.000003';
#$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/function_meta.pm ###
#package Sah::Schema::rinci::function_meta;
#
#our $DATE = '2016-12-26'; 
#our $VERSION = '1.1.82.2'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Data::Sah::Normalize ();
#use Sah::Schema::rinci::meta ();
#
#our $schema = [hash => {
#    summary => 'Rinci function metadata',
#
#    _ver => 1.1,
#    _prop => {
#        %Sah::Schema::rinci::meta::_dh_props,
#
#        entity_v => {},
#        entity_date => {},
#        links => {},
#
#        is_func => {},
#        is_meth => {},
#        is_class_meth => {},
#        args => {
#            _value_prop => {
#                %Sah::Schema::rinci::meta::_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 => {},
#                index_completion => {},
#                element_completion => {},
#                cmdline_src => {},
#                meta => 'fix',
#                element_meta => 'fix',
#                deps => {
#                    _keys => {
#                        arg => {},
#                        all => {},
#                        any => {},
#                        none => {},
#                    },
#                },
#            },
#        },
#        args_as => {},
#        args_rels => {},
#        result => {
#            _prop => {
#                %Sah::Schema::rinci::meta::_dh_props,
#
#                schema => {},
#                statuses => {
#                    _value_prop => {
#                        summary => {},
#                        description => {},
#                        schema => {},
#                    },
#                },
#                partial => {},
#                stream => {},
#            },
#        },
#        result_naked => {},
#        examples => {
#            _elem_prop => {
#                %Sah::Schema::rinci::meta::_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 => {},
#            },
#        },
#    },
#}, {}];
#
#$schema->[1]{_prop}{args}{_value_prop}{meta} = $schema->[1];
#$schema->[1]{_prop}{args}{_value_prop}{element_meta} = $schema->[1];
#
#
#$schema = Data::Sah::Normalize::normalize_schema($schema);
#
#1;
#
#__END__
#
### Sah/Schema/rinci/meta.pm ###
#package Sah::Schema::rinci::meta;
#
#our $DATE = '2016-12-26'; 
#our $VERSION = '1.1.82.2'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#our %_dh_props = (
#    v => {},
#    defhash_v => {},
#    name => {},
#    caption => {},
#    summary => {},
#    description => {},
#    tags => {},
#    default_lang => {},
#    x => {},
#);
#
#our $schema = [hash => {
#    summary => 'Rinci metadata',
#    _ver => 1.1, 
#    _prop => {
#        %_dh_props,
#
#        entity_v => {},
#        entity_date => {},
#        links => {
#            _elem_prop => {
#                %_dh_props,
#
#                url => {},
#            },
#        },
#    },
#}, {}];
#
#1;
#
#__END__
#
### Sah/Schema/rinci/result_meta.pm ###
#package Sah::Schema::rinci::result_meta;
#
#our $DATE = '2016-12-26'; 
#our $VERSION = '1.1.82.2'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Sah::Schema::rinci::meta;
#
#our $schema = [hash => {
#    summary => 'Rinci envelope result metadata',
#
#    _ver => 1.1,
#    _prop => {
#        %Sah::Schema::rinci::meta::_dh_props,
#
#        perm_err => {},
#        func => {}, 
#        cmdline => {}, 
#        logs => {},
#        prev => {},
#        results => {},
#        part_start => {},
#        part_len => {},
#        len => {},
#        stream => {},
#    },
#}, {}];
#
#1;
#
#__END__
#
### Sah/SchemaR/rinci/function_meta.pm ###
#package Sah::SchemaR::rinci::function_meta;
#
#our $DATE = '2016-12-26'; 
#our $VERSION = '1.1.82.2'; 
#
#our $rschema = do {
#  my $a = [
#    "hash",
#    [
#      {
#        _prop   => {
#                     args => {
#                       _value_prop => {
#                         caption => {},
#                         cmdline_aliases => {
#                           _value_prop => { code => {}, description => {}, is_flag => {}, schema => {}, summary => {} },
#                         },
#                         cmdline_on_getopt => {},
#                         cmdline_prompt => {},
#                         cmdline_src => {},
#                         completion => {},
#                         default => {},
#                         default_lang => {},
#                         defhash_v => {},
#                         deps => { _keys => { all => {}, any => {}, arg => {}, none => {} } },
#                         description => {},
#                         element_completion => {},
#                         element_meta => { _prop => 'fix', _ver => 1.1, summary => "Rinci function metadata" },
#                         filters => {},
#                         greedy => {},
#                         index_completion => {},
#                         is_password => {},
#                         links => {},
#                         meta => 'fix',
#                         name => {},
#                         partial => {},
#                         pos => {},
#                         req => {},
#                         schema => {},
#                         stream => {},
#                         summary => {},
#                         tags => {},
#                         v => {},
#                         x => {},
#                       },
#                     },
#                     args_as => {},
#                     args_rels => {},
#                     caption => 'fix',
#                     default_lang => 'fix',
#                     defhash_v => 'fix',
#                     deps => {
#                       _keys => {
#                         all       => {},
#                         any       => {},
#                         code      => {},
#                         env       => {},
#                         func      => {},
#                         none      => {},
#                         pkg       => {},
#                         prog      => {},
#                         tmp_dir   => {},
#                         trash_dir => {},
#                       },
#                     },
#                     description => 'fix',
#                     entity_date => {},
#                     entity_v => {},
#                     examples => {
#                       _elem_prop => {
#                         args => {},
#                         argv => {},
#                         caption => 'fix',
#                         default_lang => 'fix',
#                         defhash_v => 'fix',
#                         description => 'fix',
#                         name => 'fix',
#                         result => {},
#                         src => {},
#                         src_plang => {},
#                         status => {},
#                         summary => 'fix',
#                         tags => 'fix',
#                         test => {},
#                         v => 'fix',
#                         x => 'fix',
#                       },
#                     },
#                     features => {
#                       _keys => {
#                         check_arg => {},
#                         dry_run => {},
#                         idempotent => {},
#                         immutable => {},
#                         pure => {},
#                         reverse => {},
#                         tx => {},
#                       },
#                     },
#                     is_class_meth => {},
#                     is_func => {},
#                     is_meth => {},
#                     links => {},
#                     name => 'fix',
#                     result => {
#                       _prop => {
#                         caption => 'fix',
#                         default_lang => 'fix',
#                         defhash_v => 'fix',
#                         description => 'fix',
#                         name => 'fix',
#                         partial => {},
#                         schema => {},
#                         statuses => {
#                           _value_prop => { description => {}, schema => {}, summary => {} },
#                         },
#                         stream => {},
#                         summary => 'fix',
#                         tags => 'fix',
#                         v => 'fix',
#                         x => 'fix',
#                       },
#                     },
#                     result_naked => {},
#                     summary => 'fix',
#                     tags => 'fix',
#                     v => 'fix',
#                     x => 'fix',
#                   },
#        _ver    => 1.1,
#        summary => "Rinci function metadata",
#      },
#    ],
#    ["hash"],
#  ];
#  $a->[1][0]{_prop}{args}{_value_prop}{element_meta}{_prop} = $a->[1][0]{_prop};
#  $a->[1][0]{_prop}{args}{_value_prop}{meta} = $a->[1][0]{_prop}{args}{_value_prop}{element_meta};
#  $a->[1][0]{_prop}{caption} = $a->[1][0]{_prop}{args}{_value_prop}{caption};
#  $a->[1][0]{_prop}{default_lang} = $a->[1][0]{_prop}{args}{_value_prop}{default_lang};
#  $a->[1][0]{_prop}{defhash_v} = $a->[1][0]{_prop}{args}{_value_prop}{defhash_v};
#  $a->[1][0]{_prop}{description} = $a->[1][0]{_prop}{args}{_value_prop}{description};
#  $a->[1][0]{_prop}{examples}{_elem_prop}{caption} = $a->[1][0]{_prop}{args}{_value_prop}{caption};
#  $a->[1][0]{_prop}{examples}{_elem_prop}{default_lang} = $a->[1][0]{_prop}{args}{_value_prop}{default_lang};
#  $a->[1][0]{_prop}{examples}{_elem_prop}{defhash_v} = $a->[1][0]{_prop}{args}{_value_prop}{defhash_v};
#  $a->[1][0]{_prop}{examples}{_elem_prop}{description} = $a->[1][0]{_prop}{args}{_value_prop}{description};
#  $a->[1][0]{_prop}{examples}{_elem_prop}{name} = $a->[1][0]{_prop}{args}{_value_prop}{name};
#  $a->[1][0]{_prop}{examples}{_elem_prop}{summary} = $a->[1][0]{_prop}{args}{_value_prop}{summary};
#  $a->[1][0]{_prop}{examples}{_elem_prop}{tags} = $a->[1][0]{_prop}{args}{_value_prop}{tags};
#  $a->[1][0]{_prop}{examples}{_elem_prop}{v} = $a->[1][0]{_prop}{args}{_value_prop}{v};
#  $a->[1][0]{_prop}{examples}{_elem_prop}{x} = $a->[1][0]{_prop}{args}{_value_prop}{x};
#  $a->[1][0]{_prop}{name} = $a->[1][0]{_prop}{args}{_value_prop}{name};
#  $a->[1][0]{_prop}{result}{_prop}{caption} = $a->[1][0]{_prop}{args}{_value_prop}{caption};
#  $a->[1][0]{_prop}{result}{_prop}{default_lang} = $a->[1][0]{_prop}{args}{_value_prop}{default_lang};
#  $a->[1][0]{_prop}{result}{_prop}{defhash_v} = $a->[1][0]{_prop}{args}{_value_prop}{defhash_v};
#  $a->[1][0]{_prop}{result}{_prop}{description} = $a->[1][0]{_prop}{args}{_value_prop}{description};
#  $a->[1][0]{_prop}{result}{_prop}{name} = $a->[1][0]{_prop}{args}{_value_prop}{name};
#  $a->[1][0]{_prop}{result}{_prop}{summary} = $a->[1][0]{_prop}{args}{_value_prop}{summary};
#  $a->[1][0]{_prop}{result}{_prop}{tags} = $a->[1][0]{_prop}{args}{_value_prop}{tags};
#  $a->[1][0]{_prop}{result}{_prop}{v} = $a->[1][0]{_prop}{args}{_value_prop}{v};
#  $a->[1][0]{_prop}{result}{_prop}{x} = $a->[1][0]{_prop}{args}{_value_prop}{x};
#  $a->[1][0]{_prop}{summary} = $a->[1][0]{_prop}{args}{_value_prop}{summary};
#  $a->[1][0]{_prop}{tags} = $a->[1][0]{_prop}{args}{_value_prop}{tags};
#  $a->[1][0]{_prop}{v} = $a->[1][0]{_prop}{args}{_value_prop}{v};
#  $a->[1][0]{_prop}{x} = $a->[1][0]{_prop}{args}{_value_prop}{x};
#  $a;
#};
#
#1;
#
#__END__
#
### Sah/SchemaR/rinci/meta.pm ###
#package Sah::SchemaR::rinci::meta;
#
#our $DATE = '2016-12-26'; 
#our $VERSION = '1.1.82.2'; 
#
#our $rschema = do {
#  my $a = [
#    "hash",
#    [
#      {
#        _prop   => {
#                     caption => {},
#                     default_lang => {},
#                     defhash_v => {},
#                     description => {},
#                     entity_date => {},
#                     entity_v => {},
#                     links => {
#                       _elem_prop => {
#                         caption => 'fix',
#                         default_lang => 'fix',
#                         defhash_v => 'fix',
#                         description => 'fix',
#                         name => {},
#                         summary => {},
#                         tags => {},
#                         url => {},
#                         v => {},
#                         x => {},
#                       },
#                     },
#                     name => 'fix',
#                     summary => 'fix',
#                     tags => 'fix',
#                     v => 'fix',
#                     x => 'fix',
#                   },
#        _ver    => 1.1,
#        summary => "Rinci metadata",
#      },
#    ],
#    ["hash"],
#  ];
#  $a->[1][0]{_prop}{links}{_elem_prop}{caption} = $a->[1][0]{_prop}{caption};
#  $a->[1][0]{_prop}{links}{_elem_prop}{default_lang} = $a->[1][0]{_prop}{default_lang};
#  $a->[1][0]{_prop}{links}{_elem_prop}{defhash_v} = $a->[1][0]{_prop}{defhash_v};
#  $a->[1][0]{_prop}{links}{_elem_prop}{description} = $a->[1][0]{_prop}{description};
#  $a->[1][0]{_prop}{name} = $a->[1][0]{_prop}{links}{_elem_prop}{name};
#  $a->[1][0]{_prop}{summary} = $a->[1][0]{_prop}{links}{_elem_prop}{summary};
#  $a->[1][0]{_prop}{tags} = $a->[1][0]{_prop}{links}{_elem_prop}{tags};
#  $a->[1][0]{_prop}{v} = $a->[1][0]{_prop}{links}{_elem_prop}{v};
#  $a->[1][0]{_prop}{x} = $a->[1][0]{_prop}{links}{_elem_prop}{x};
#  $a;
#};
#
#1;
#
#__END__
#
### Sah/SchemaR/rinci/result_meta.pm ###
#package Sah::SchemaR::rinci::result_meta;
#
#our $DATE = '2016-12-26'; 
#our $VERSION = '1.1.82.2'; 
#
#our $rschema = [
#  "hash",
#  [
#    {
#      _prop   => {
#                   caption => {},
#                   cmdline => {},
#                   default_lang => {},
#                   defhash_v => {},
#                   description => {},
#                   func => {},
#                   len => {},
#                   logs => {},
#                   name => {},
#                   part_len => {},
#                   part_start => {},
#                   perm_err => {},
#                   prev => {},
#                   results => {},
#                   stream => {},
#                   summary => {},
#                   tags => {},
#                   v => {},
#                   x => {},
#                 },
#      _ver    => 1.1,
#      summary => "Rinci envelope result metadata",
#    },
#  ],
#  ["hash"],
#];
#
#1;
#
#__END__
#
### Sah/Schemas/Rinci.pm ###
#package Sah::Schemas::Rinci;
#
#our $DATE = '2016-12-26'; 
#our $VERSION = '1.1.82.2'; 
#
#1;
#
#__END__
#
### Scalar/Util/Numeric/PP.pm ###
#package Scalar::Util::Numeric::PP;
#
#our $DATE = '2016-01-22'; 
#our $VERSION = '0.04'; 
#
#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\s*[+-]?(?:0|[1-9][0-9]*)\s*\z/s;
#    0;
#}
#
#sub isnan($) {
#    local $_ = shift;
#    return 0 unless defined;
#    return 1 if /\A\s*[+-]?nan\s*\z/is;
#    0;
#}
#
#sub isinf($) {
#    local $_ = shift;
#    return 0 unless defined;
#    return 1 if /\A\s*[+-]?inf(?:inity)?\s*\z/is;
#    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\s*[+-]?
#                 (?: (?:0|[1-9][0-9]*)(\.[0-9]+)? | (\.[0-9]+) )
#                 ([eE][+-]?[0-9]+)?\s*\z/sx && $1 || $2 || $3;
#    return 1 if isnan($_) || isinf($_);
#    0;
#}
#
#1;
#
#__END__
#
### String/Elide/Parts.pm ###
#package String::Elide::Parts;
#
#our $DATE = '2017-01-29'; 
#our $VERSION = '0.07'; 
#
#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 $default_prio = $opts->{default_prio} // 1;
#
#    my @parts;
#    my @parts_attrs;
#    while ($str =~ m#<elspan([^>]*)>(.*?)</elspan>|(.*?)(?=<elspan)|(.*)#gs) {
#        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) {
#        if (defined $parts_attrs[$i]) {
#            my $attrs = {};
#            $attrs->{truncate} = $1 // $2
#                if $parts_attrs[$i] =~ /\btruncate=(?:"([^"]*)"|(\S+))/;
#            $attrs->{marker} = $1 // $2
#                if $parts_attrs[$i] =~ /\bmarker=(?:"([^"]*)"|(\S+))/;
#            $attrs->{prio} = $1 // $2
#                if $parts_attrs[$i] =~ /\bprio(?:rity)?=(?:"([^"]*)"|(\S+))/;
#            $parts_attrs[$i] = $attrs;
#        } else {
#            $parts_attrs[$i] = {prio=>$default_prio};
#        }
#    }
#
#
#  PRIO:
#    while (1) {
#        my $all_parts_len = 0;
#        $all_parts_len += length($_) for @parts;
#
#        if ($all_parts_len <= $len) {
#            return join("", @parts);
#        }
#
#        my $highest_prio;
#        for (@parts_attrs) {
#            $highest_prio = $_->{prio} if !defined($highest_prio) ||
#                $highest_prio < $_->{prio};
#        }
#        my @high_indexes;
#        my $high_parts_len = 0;
#        for my $i (0..$#parts_attrs) {
#            if ($parts_attrs[$i]{prio} == $highest_prio) {
#                $high_parts_len += length $parts[$i];
#                push @high_indexes, $i;
#            }
#        }
#
#        if ($all_parts_len - $high_parts_len >= $len) {
#            for (reverse @high_indexes) {
#                splice @parts, $_, 1;
#                splice @parts_attrs, $_, 1;
#                next PRIO;
#            }
#        }
#
#
#        my @must_elide_total_len_after_this;
#        my $tot_to_elide = $all_parts_len - $len;
#        for my $i (0..$#high_indexes) {
#            $must_elide_total_len_after_this[$i] =
#                int( ($i+1)/@high_indexes * $tot_to_elide );
#        }
#
#        my $tot_already_elided = 0;
#        my $tot_still_to_elide = 0;
#        for my $i (reverse 0..$#high_indexes) {
#            my $idx = $high_indexes[$i];
#            my $part_len = length $parts[$idx];
#            my $to_elide = $must_elide_total_len_after_this[$#high_indexes - $i] -
#                $tot_already_elided;
#            if ($to_elide <= 0) {
#            } elsif ($part_len <= $to_elide) {
#                splice @parts, $idx, 1;
#                splice @parts_attrs, $idx, 1;
#                $tot_already_elided += $part_len;
#                $tot_still_to_elide += ($to_elide - $part_len);
#            } else {
#                $parts[$idx] = _elide_part(
#                    $parts[$idx],
#                    $part_len - $to_elide,
#                    $parts_attrs[$idx]{marker} // $marker,
#                    $parts_attrs[$idx]{truncate} // $truncate,
#                );
#                $tot_already_elided += $to_elide;
#                $tot_still_to_elide = 0;
#            }
#        }
#
#    } 
#}
#
#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 = '2016-10-07'; 
#our $VERSION = '0.02'; 
#
#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/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);
#use Carp qw(croak);
#
#our $VERSION = '2.002004';
#$VERSION = eval $VERSION;
#
#our @EXPORT = qw(defer_sub undefer_sub undefer_all);
#our @EXPORT_OK = qw(undefer_package defer_info);
#
#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;
#  undefer_sub($_)
#    for grep {
#      my $name = $DEFERRED{$_} && $DEFERRED{$_}[0];
#      $name && $name =~ /^${package}::[^:]+$/
#    } keys %DEFERRED;
#  return;
#}
#
#sub defer_info {
#  my ($deferred) = @_;
#  my $info = $DEFERRED{$deferred||''} or return undef;
#  [ @$info ];
#}
#
#sub defer_sub {
#  my ($target, $maker, $options) = @_;
#  my $package;
#  my $subname;
#  ($package, $subname) = $target =~ /^(.*)::([^:]+)$/
#    or croak "$target is not a fully qualified sub name!"
#    if $target;
#  $package ||= $options && $options->{package} || caller;
#  my @attributes = @{$options && $options->{attributes} || []};
#  my $deferred;
#  my $undeferred;
#  my $deferred_info = [ $target, $maker, \$undeferred ];
#  if (@attributes || $target && !Moo::_Utils::_CAN_SUBNAME) {
#    my $code
#      =  q[#line ].(__LINE__+2).q[ "].__FILE__.qq["\n]
#      . qq[package $package;\n]
#      . ($target ? "sub $subname" : '+sub') . join(' ', map ":$_", @attributes)
#      . q[ {
#        package Sub::Defer;
#        # uncoverable subroutine
#        # uncoverable statement
#        $undeferred ||= undefer_sub($deferred_info->[3]);
#        goto &$undeferred; # uncoverable statement
#        $undeferred; # fake lvalue return
#      }]."\n"
#      . ($target ? "\\&$subname" : '');
#    my $e;
#    $deferred = do {
#      no warnings qw(redefine closure);
#      local $@;
#      eval $code or $e = $@; 
#    };
#    die $e if defined $e; 
#  }
#  else {
#    $deferred = sub {
#      $undeferred ||= undefer_sub($deferred_info->[3]);
#      goto &$undeferred;
#    };
#    _install_coderef($target, $deferred)
#      if $target;
#  }
#  weaken($deferred_info->[3] = $deferred);
#  weaken($DEFERRED{$deferred} = $deferred_info);
#  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/Quote.pm ###
#package Sub::Quote;
#
#sub _clean_eval { eval $_[0] }
#
#use Moo::_strictures;
#
#use Sub::Defer qw(defer_sub);
#use Moo::_Utils qw(_install_coderef);
#use Scalar::Util qw(weaken);
#use Exporter qw(import);
#use Carp qw(croak);
#BEGIN { our @CARP_NOT = qw(Sub::Defer) }
#use B ();
#BEGIN {
#  *_HAVE_PERLSTRING = defined &B::perlstring ? sub(){1} : sub(){0};
#}
#
#our $VERSION = '2.002004';
#$VERSION = eval $VERSION;
#
#our @EXPORT = qw(quote_sub unquote_sub quoted_from_sub qsub);
#our @EXPORT_OK = qw(quotify capture_unroll inlinify sanitize_identifier);
#
#our %QUOTED;
#
#sub quotify {
#  no warnings 'numeric';
#  ! defined $_[0]     ? 'undef()'
#  : (length( (my $dummy = '') & $_[0] )
#    && 0 + $_[0] eq $_[0]
#    && $_[0] * 0 == 0
#  ) ? $_[0]
#  : _HAVE_PERLSTRING  ? B::perlstring($_[0])
#  : qq["\Q$_[0]\E"];
#}
#
#sub sanitize_identifier {
#  my $name = shift;
#  $name =~ s/([_\W])/sprintf('_%x', ord($1))/ge;
#  $name;
#}
#
#sub capture_unroll {
#  my ($from, $captures, $indent) = @_;
#  join(
#    '',
#    map {
#      /^([\@\%\$])/
#        or croak "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];
#  if ($name) {
#    my $subname = $name;
#    my $package = $subname =~ s/(.*)::// ? $1 : caller;
#    $name = join '::', $package, $subname;
#    croak "package name $package too long!"
#      if length $package > 252;
#    croak "sub name $subname too long!"
#      if length $subname > 252;
#  }
#  my @caller = caller(0);
#  my $attributes = $options->{attributes};
#  my $quoted_info = {
#    name     => $name,
#    code     => $code,
#    captures => $captures,
#    package      => (exists $options->{package}      ? $options->{package}      : $caller[0]),
#    hints        => (exists $options->{hints}        ? $options->{hints}        : $caller[8]),
#    warning_bits => (exists $options->{warning_bits} ? $options->{warning_bits} : $caller[9]),
#    hintshash    => (exists $options->{hintshash}    ? $options->{hintshash}    : $caller[10]),
#    ($attributes ? (attributes => $attributes) : ()),
#  };
#  my $unquoted;
#  weaken($quoted_info->{unquoted} = \$unquoted);
#  if ($options->{no_defer}) {
#    my $fake = \my $var;
#    local $QUOTED{$fake} = $quoted_info;
#    my $sub = unquote_sub($fake);
#    _install_coderef($name, $sub) if $name && !$options->{no_install};
#    return $sub;
#  }
#  else {
#    my $deferred = defer_sub +($options->{no_install} ? undef : $name) => sub {
#      $unquoted if 0;
#      unquote_sub($quoted_info->{deferred});
#    }, ($attributes ? { attributes => $attributes } : ());
#    weaken($quoted_info->{deferred} = $deferred);
#    weaken($QUOTED{$deferred} = $quoted_info);
#    return $deferred;
#  }
#}
#
#sub _context {
#  my $info = shift;
#  $info->{context} ||= do {
#    my ($package, $hints, $warning_bits, $hintshash)
#      = @{$info}{qw(package hints warning_bits hintshash)};
#
#    $info->{context}
#      ="# BEGIN quote_sub PRELUDE\n"
#      ."package $package;\n"
#      ."BEGIN {\n"
#      ."  \$^H = ".quotify($hints).";\n"
#      ."  \${^WARNING_BITS} = ".quotify($warning_bits).";\n"
#      ."  \%^H = (\n"
#      . join('', map
#      "    ".quotify($_)." => ".quotify($hintshash->{$_}).",\n",
#        keys %$hintshash)
#      ."  );\n"
#      ."}\n"
#      ."# END quote_sub PRELUDE\n";
#  };
#}
#
#sub quoted_from_sub {
#  my ($sub) = @_;
#  my $quoted_info = $QUOTED{$sub||''} or return undef;
#  my ($name, $code, $captures, $unquoted, $deferred)
#    = @{$quoted_info}{qw(name code captures unquoted deferred)};
#  $code = _context($quoted_info) . $code;
#  $unquoted &&= $$unquoted;
#  if (($deferred && $deferred eq $sub)
#      || ($unquoted && $unquoted eq $sub)) {
#    return [ $name, $code, $captures, $unquoted, $deferred ];
#  }
#  return undef;
#}
#
#sub unquote_sub {
#  my ($sub) = @_;
#  my $quoted_info = $QUOTED{$sub} or return undef;
#  my $unquoted = $quoted_info->{unquoted};
#  unless ($unquoted && $$unquoted) {
#    my ($name, $code, $captures, $package, $attributes)
#      = @{$quoted_info}{qw(name code captures package attributes)};
#
#    ($package, $name) = $name =~ /(.*)::(.*)/
#      if $name;
#
#    my %captures = $captures ? %$captures : ();
#    $captures{'$_UNQUOTED'} = \$unquoted;
#    $captures{'$_QUOTED'} = \$quoted_info;
#
#    my $make_sub
#      = "{\n"
#      . capture_unroll("\$_[1]", \%captures, 2)
#      . "  package ${package};\n"
#      . (
#        $name
#          ? "  no warnings 'closure';\n  sub ${name} "
#          : "  \$\$_UNQUOTED = sub "
#      )
#      . ($attributes ? join('', map ":$_ ", @$attributes) : '') . "{\n"
#      . "  (\$_QUOTED,\$_UNQUOTED) if 0;\n"
#      . _context($quoted_info)
#      . $code
#      . "  }".($name ? "\n  \$\$_UNQUOTED = \\&${name}" : '') . ";\n"
#      . "}\n"
#      . "1;\n";
#    $ENV{SUB_QUOTE_DEBUG} && warn $make_sub;
#    {
#      no strict 'refs';
#      local *{"${package}::${name}"} if $name;
#      my ($success, $e);
#      {
#        local $@;
#        $success = _clean_eval($make_sub, \%captures);
#        $e = $@;
#      }
#      unless ($success) {
#        croak "Eval went very, very wrong:\n\n${make_sub}\n\n$e";
#      }
#      weaken($QUOTED{$$unquoted} = $quoted_info);
#    }
#  }
#  $$unquoted;
#}
#
#sub qsub ($) {
#  goto &quote_sub;
#}
#
#sub CLONE {
#  %QUOTED = map { defined $_ ? (
#    $_->{unquoted} && ${$_->{unquoted}} ? (${ $_->{unquoted} } => $_) : (),
#    $_->{deferred} ? ($_->{deferred} => $_) : (),
#  ) : () } values %QUOTED;
#  weaken($_) for values %QUOTED;
#}
#
#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 = '2017-01-16'; 
#our $VERSION = '0.32'; 
#
#use 5.010;
#use strict;
#use warnings;
#
#use Test::More 0.98;
#
#our $CLASS = "Config::IOD::Reader";
#
#sub test_common_iod {
#
#    eval "require $CLASS"; die if $@;
#
#    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 = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use 5.010;
#use strict;
#use warnings;
#use Test::More 0.98;
#
#use Data::Dump qw(dump);
#use Data::Sah qw(gen_validator);
#use File::chdir;
#use File::Slurper qw(read_text);
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(
#                       test_sah_cases
#                       run_spectest
#                       all_match
#                       any_match
#                       none_match
#               );
#
#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----";
#    }
#}
#
#sub _decode_json {
#    state $json = do {
#        require JSON;
#        JSON->new->allow_nonref;
#    };
#    $json->decode(@_);
#}
#
#sub run_spectest {
#    require File::ShareDir;
#    require File::ShareDir::Tarball;
#    require Sah;
#
#    my %args = @_;
#
#    my $sah = Data::Sah->new;
#
#    my $dir;
#    if (version->parse($Sah::VERSION) == version->parse("0.9.27")) {
#        $dir = File::ShareDir::dist_dir("Sah");
#    } else {
#        $dir = File::ShareDir::Tarball::dist_dir("Sah");
#    }
#    $dir && (-d $dir) or die "Can't find spectest, have you installed Sah?";
#    (-f "$dir/spectest/00-normalize_schema.json")
#        or die "Something's wrong, spectest doesn't contain the correct files";
#
#    my @specfiles;
#    {
#        local $CWD = "$dir/spectest";
#        @specfiles = <*.json>;
#    }
#
#    my @files;
#    if ($ENV{TEST_SAH_SPECTEST_FILES}) {
#        @files = split /\s*,\s*|\s+/, $ENV{TEST_SAH_SPECTEST_FILES};
#    } else {
#        @files = @ARGV;
#    }
#
#    my @types;
#    if ($ENV{TEST_SAH_SPECTEST_TYPES}) {
#        @types = split /\s*,\s*|\s+/, $ENV{TEST_SAH_SPECTEST_TYPES};
#    }
#
#    my @include_tags;
#    if ($ENV{TEST_SAH_SPECTEST_INCLUDE_TAGS}) {
#        @include_tags = split /\s*,\s*|\s+/,
#            $ENV{TEST_SAH_SPECTEST_INCLUDE_TAGS};
#    }
#
#    my @exclude_tags;
#    if ($ENV{TEST_SAH_SPECTEST_EXCLUDE_TAGS}) {
#        @exclude_tags = split /\s*,\s*|\s+/,
#            $ENV{TEST_SAH_SPECTEST_EXCLUDE_TAGS};
#    }
#
#    my $code_test_excluded = sub {
#        my $test = shift;
#
#        if ($test->{tags} && @exclude_tags) {
#            if (any_match(\@exclude_tags, $test->{tags})) {
#                return "contains excluded tag(s) (".
#                    join(", ", @exclude_tags).")";
#            }
#        }
#        if (@include_tags) {
#            if (!all_match(\@include_tags, $test->{tags} // [])) {
#                return "does not contain all include tags (".
#                    join(", ", @include_tags).")";
#            }
#        }
#        "";
#    };
#
#    {
#        use experimental 'smartmatch';
#
#        last unless $args{test_normalize_schema};
#
#        for my $file ("00-normalize_schema.json") {
#            unless (!@files || $file ~~ @files) {
#                diag "Skipping file $file";
#                next;
#            }
#            subtest $file => sub {
#                my $tspec = _decode_json(~~read_text("$dir/spectest/$file"));
#                for my $test (@{ $tspec->{tests} }) {
#                    subtest $test->{name} => sub {
#                        if (my $reason = $code_test_excluded->($test)) {
#                            plan skip_all => "Skipping test $test->{name}: $reason";
#                            return;
#                        }
#                        eval {
#                            is_deeply(normalize_schema($test->{input}),
#                                      $test->{result}, "result");
#                        };
#                        my $eval_err = $@;
#                        if ($test->{dies}) {
#                            ok($eval_err, "dies");
#                        } else {
#                            ok(!$eval_err, "doesn't die")
#                                or diag $eval_err;
#                        }
#                    };
#                }
#                ok 1; 
#            };
#        }
#    }
#
#    {
#        use experimental 'smartmatch';
#
#        last unless $args{test_merge_clause_sets};
#
#        for my $file ("01-merge_clause_sets.json") {
#            last; 
#            unless (!@files || $file ~~ @files) {
#                diag "Skipping file $file";
#                next;
#            }
#            subtest $file => sub {
#                my $tspec = _decode_json(~~read_text("$dir/spectest/$file"));
#                for my $test (@{ $tspec->{tests} }) {
#                    subtest $test->{name} => sub {
#                        if (my $reason = $code_test_excluded->($test)) {
#                            plan skip_all => "Skipping test $test->{name}: $reason";
#                            return;
#                        }
#                        eval {
#                            is_deeply($sah->_merge_clause_sets(@{ $test->{input} }),
#                                      $test->{result}, "result");
#                        };
#                        my $eval_err = $@;
#                        if ($test->{dies}) {
#                            ok($eval_err, "dies");
#                        } else {
#                            ok(!$eval_err, "doesn't die")
#                                or diag $eval_err;
#                        }
#                    };
#                }
#                ok 1; 
#            };
#        }
#    }
#
#    {
#        use experimental 'smartmatch';
#
#        for my $file (grep /^10-type-/, @specfiles) {
#            unless (!@files || $file ~~ @files) {
#                diag "Skipping file $file";
#                next;
#            }
#            subtest $file => sub {
#                diag "Loading $file ...";
#                my $tspec = _decode_json(~~read_text("$dir/spectest/$file"));
#                note "Test version: ", $tspec->{version};
#                my $tests = $tspec->{tests};
#                if ($args{tests_func}) {
#                    $args{tests_func}->($tests, {
#                        parent_args => \%args,
#                        code_test_excluded => $code_test_excluded,
#                    });
#                } elsif ($args{test_func}) {
#                    for my $test (@$tests) {
#                        my $skip_reason;
#                        {
#                            if ($args{skip_if}) {
#                                $skip_reason = $args{skip_if}->($test);
#                                last if $skip_reason;
#                            }
#                            $skip_reason = $code_test_excluded->($test);
#                            last if $skip_reason;
#                        }
#                        my $tname = "(tags=".join(", ", sort @{ $test->{tags} // [] }).
#                            ") $test->{name}";
#                        if ($skip_reason) {
#                            diag "Skipping test $tname: $skip_reason";
#                            next;
#                        }
#                        note explain $test;
#                        subtest $tname => sub {
#                            $args{test_func}->($test);
#                        };
#                    } 
#                    ok 1; 
#                } else {
#                    die "Please specify 'test_func' or 'tests_func'";
#                }
#            }; 
#        } 
#    }
#
#}
#
#sub all_match {
#    use experimental 'smartmatch';
#
#    my ($list1, $list2) = @_;
#
#    for (@$list1) {
#        return 0 unless $_ ~~ @$list2;
#    }
#    1;
#}
#
#sub any_match {
#    use experimental 'smartmatch';
#
#    my ($list1, $list2) = @_;
#
#    for (@$list1) {
#        return 1 if $_ ~~ @$list2;
#    }
#    0;
#}
#
#sub none_match {
#    use experimental 'smartmatch';
#
#    my ($list1, $list2) = @_;
#
#    for (@$list1) {
#        return 0 if $_ ~~ @$list2;
#    }
#    1;
#}
#
#1;
#
#__END__
#
### Test/Data/Sah/Human.pm ###
#package Test::Data::Sah::Human;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use 5.010001;
#use strict;
#use warnings;
#use Test::More 0.98;
#
#use Data::Sah;
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(test_human);
#
#sub test_human {
#    my %args = @_;
#    subtest $args{name} // $args{result}, sub {
#        my $sah = Data::Sah->new;
#        my $hc = $sah->get_compiler("human");
#        my %hargs = (
#            schema => $args{schema},
#            lang => $args{lang},
#            %{ $args{compile_opts} // {} },
#        );
#        $hargs{format} //= "inline_text";
#        my $cd = $hc->compile(%hargs);
#
#        if (defined $args{result}) {
#            if (ref($args{result}) eq 'Regexp') {
#                like($cd->{result}, $args{result}, 'result');
#            } else {
#                is($cd->{result}, $args{result}, 'result');
#            }
#        }
#    };
#}
#
#1;
#
#__END__
#
### Test/Data/Sah/Perl.pm ###
#package Test::Data::Sah::Perl;
#
#our $DATE = '2016-09-14'; 
#our $VERSION = '0.87'; 
#
#use 5.010001;
#use strict;
#use warnings;
#
#use Test::Data::Sah qw(run_spectest all_match);
#use Test::More 0.98;
#
#use Data::Sah qw(gen_validator);
#
#use Exporter qw(import);
#our @EXPORT_OK = qw(run_spectest_for_perl);
#
#sub run_spectest_for_perl {
#    run_spectest(
#        test_merge_clause_sets => 1,
#        test_func => sub {
#            my $test = shift;
#
#            my $data = $test->{input};
#            my $ho = exists($test->{output}); 
#            my $vbool;
#            eval { $vbool = gen_validator(
#                $test->{schema}, {accept_ref=>$ho}) };
#            my $eval_err = $@;
#            if ($test->{dies}) {
#                ok($eval_err, "compile error");
#                return;
#            } else {
#                ok(!$eval_err, "compile success") or do {
#                    diag $eval_err;
#                    return;
#                };
#            }
#
#            if ($test->{valid_inputs}) {
#                for my $i (0..@{ $test->{valid_inputs} }-1) {
#                    my $data = $test->{valid_inputs}[$i];
#                    ok($vbool->($ho ? \$data : $data), "valid input [$i]");
#                }
#                for my $i (0..@{ $test->{invalid_inputs} }-1) {
#                    my $data = $test->{invalid_inputs}[$i];
#                    ok(!$vbool->($ho ? \$data : $data), "invalid input [$i]");
#                }
#            } elsif (exists $test->{valid}) {
#                if ($test->{valid}) {
#                    ok($vbool->($ho ? \$data : $data), "valid (rt=bool)");
#                    if ($ho) {
#                        is_deeply($data, $test->{output}, "output");
#                    }
#                } else {
#                    ok(!$vbool->($ho ? \$data : $data), "invalid (rt=bool)");
#                }
#            }
#
#            my $vstr = gen_validator($test->{schema},
#                                     {return_type=>'str'});
#            if (exists $test->{valid}) {
#                if ($test->{valid}) {
#                    is($vstr->($test->{input}), "", "valid (rt=str)");
#                } else {
#                    like($vstr->($test->{input}), qr/\S/, "invalid (rt=str)");
#                }
#            }
#
#            my $vfull = gen_validator($test->{schema},
#                                      {return_type=>'full'});
#            my $res = $vfull->($test->{input});
#            is(ref($res), 'HASH', "validator (rt=full) returns hash");
#            if (exists($test->{errors}) || exists($test->{warnings}) ||
#                    exists($test->{valid})) {
#                my $errors = $test->{errors} // ($test->{valid} ? 0 : 1);
#                is(scalar(keys %{ $res->{errors} // {} }), $errors, "errors (rt=full)")
#                    or diag explain $res;
#                my $warnings = $test->{warnings} // 0;
#                is(scalar(keys %{ $res->{warnings} // {} }), $warnings,
#                   "warnings (rt=full)")
#                    or diag explain $res;
#            }
#        }, 
#
#        skip_if => sub {
#            my $t = shift;
#            return 0 unless $t->{tags};
#
#            return "currently failing"
#                if all_match([qw/type:bool clause:between op/], $t->{tags});
#
#            for (qw/
#
#                       check
#                       check_each_elem
#                       check_each_index
#                       check_each_key
#                       check_each_value
#                       check_prop
#                       exists
#                       if
#                       postfilters
#                       prefilters
#                       prop
#                       uniq
#
#                   /) {
#                return "clause $_ not yet implemented"
#                    if all_match(["clause:$_"], $t->{tags});
#            }
#
#            return "properties are not yet implemented"
#                if grep {/^prop:/} @{ $t->{tags} };
#
#            0;
#        }, 
#
#    );
#}
#
#1;
#
#__END__
#
### Test/Perinci/Sub/Wrapper.pm ###
#package Test::Perinci::Sub::Wrapper;
#
#our $DATE = '2016-06-02'; 
#our $VERSION = '0.83'; 
#
#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 = '2016-03-11'; 
#our $VERSION = '0.22'; 
#
#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)) if $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/Util.pm ###
#package Text::ANSI::Util;
#
#our $DATE = '2016-03-11'; 
#our $VERSION = '0.22'; 
#
#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/ANSITable.pm ###
#package Text::ANSITable;
#
#our $DATE = '2016-03-11'; 
#our $VERSION = '0.48'; 
#
#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::MaybeXS;
#        my $sets = JSON::MaybeXS::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::MaybeXS;
#        my $s = JSON::MaybeXS::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::Util;
#    $self->{_func_add_color_resets} = \&Text::ANSI::Util::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::Util::ta_length_height;
#        $self->{_func_pad}           = \&Text::ANSI::Util::ta_pad;
#        $self->{_func_wrap}          = \&Text::ANSI::Util::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::MaybeXS;
#        my $ss = JSON::MaybeXS::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::MaybeXS;
#        my $ss = JSON::MaybeXS::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::MaybeXS;
#        my $ss = JSON::MaybeXS::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 = '2016-03-11'; 
#our $VERSION = '0.48'; 
#
#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 = '2016-03-11'; 
#our $VERSION = '0.48'; 
#
#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 = '2016-03-11'; 
#our $VERSION = '0.48'; 
#
#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/Any.pm ###
#package Text::Table::Any;
#
#our $DATE = '2017-01-01'; 
#our $VERSION = '0.08'; 
#
#
#sub _encode {
#    my $val = shift;
#    $val =~ s/([\\"])/\\$1/g;
#    "\"$val\"";
#}
#
#sub table {
#    my %params = @_;
#
#    my $rows       = $params{rows} or die "Must provide rows!";
#    my $backend    = $params{backend} || 'Text::Table::Tiny';
#    my $header_row = $params{header_row} // 0;
#
#    if ($backend eq 'Text::Table::Tiny') {
#        require Text::Table::Tiny;
#        return Text::Table::Tiny::table(
#            rows => $rows, header_row => $header_row) . "\n";
#    } elsif ($backend eq 'Text::Table::TinyColor') {
#        require Text::Table::TinyColor;
#        return Text::Table::TinyColor::table(
#            rows => $rows, header_row => $header_row) . "\n";
#    } elsif ($backend eq 'Text::Table::TinyColorWide') {
#        require Text::Table::TinyColorWide;
#        return Text::Table::TinyColorWide::table(
#            rows => $rows, header_row => $header_row) . "\n";
#    } elsif ($backend eq 'Text::Table::TinyWide') {
#        require Text::Table::TinyWide;
#        return Text::Table::TinyWide::table(
#            rows => $rows, header_row => $header_row) . "\n";
#    } elsif ($backend eq 'Text::Table::Org') {
#        require Text::Table::Org;
#        return Text::Table::Org::table(
#            rows => $rows, header_row => $header_row);
#    } elsif ($backend eq 'Text::Table::CSV') {
#        require Text::Table::CSV;
#        return Text::Table::CSV::table(
#            rows => $rows);
#    } elsif ($backend eq 'Text::Table::HTML') {
#        require Text::Table::HTML;
#        return Text::Table::HTML::table(
#            rows => $rows, header_row => $header_row);
#    } elsif ($backend eq 'Text::Table::HTML::DataTables') {
#        require Text::Table::HTML::DataTables;
#        return Text::Table::HTML::DataTables::table(
#            rows => $rows, header_row => $header_row);
#    } elsif ($backend eq 'Text::Table::Paragraph') {
#        require Text::Table::Paragraph;
#        return Text::Table::Paragraph::table(
#            rows => $rows, header_row => $header_row);
#    } elsif ($backend eq 'Text::ANSITable') {
#        require Text::ANSITable;
#        my $t = Text::ANSITable->new(
#            use_utf8 => 0,
#            use_box_chars => 0,
#            use_color => 0,
#            border_style => 'Default::single_ascii',
#        );
#        if ($header_row) {
#            $t->columns($rows->[0]);
#            $t->add_row($rows->[$_]) for 1..@$rows-1;
#        } else {
#            $t->columns([ map {"col$_"} 0..$#{$rows->[0]} ]);
#            $t->add_row($_) for @$rows;
#        }
#        return $t->draw;
#    } elsif ($backend eq 'Text::ASCIITable') {
#        require Text::ASCIITable;
#        my $t = Text::ASCIITable->new();
#        if ($header_row) {
#            $t->setCols(@{ $rows->[0] });
#            $t->addRow(@{ $rows->[$_] }) for 1..@$rows-1;
#        } else {
#            $t->setCols(map { "col$_" } 0..$#{ $rows->[0] });
#            $t->addRow(@$_) for @$rows;
#        }
#        return "$t";
#    } elsif ($backend eq 'Text::FormatTable') {
#        require Text::FormatTable;
#        my $t = Text::FormatTable->new(join('|', ('l') x @{ $rows->[0] }));
#        $t->head(@{ $rows->[0] });
#        $t->row(@{ $rows->[$_] }) for 1..@$rows-1;
#        return $t->render;
#    } elsif ($backend eq 'Text::MarkdownTable') {
#        require Text::MarkdownTable;
#        my $out = "";
#        my $fields =  $header_row ?
#            $rows->[0] : [map {"col$_"} 0..$#{ $rows->[0] }];
#        my $t = Text::MarkdownTable->new(file => \$out, columns => $fields);
#        foreach (($header_row ? 1:0) .. $#{$rows}) {
#            my $row = $rows->[$_];
#            $t->add( {
#                map { $fields->[$_] => $row->[$_] } 0..@$fields-1
#            });
#        }
#        $t->done;
#        return $out;
#    } elsif ($backend eq 'Text::Table') {
#        require Text::Table;
#        my $t = Text::Table->new(@{ $rows->[0] });
#        $t->load(@{ $rows }[1..@$rows-1]);
#        return $t;
#    } elsif ($backend eq 'Text::TabularDisplay') {
#        require Text::TabularDisplay;
#        my $t = Text::TabularDisplay->new(@{ $rows->[0] });
#        $t->add(@{ $rows->[$_] }) for 1..@$rows-1;
#        return $t->render . "\n";
#    } else {
#        die "Unknown backend '$backend'";
#    }
#}
#
#1;
#
#__END__
#
### Text/Table/Tiny.pm ###
#use 5.006;
#use strict;
#use warnings;
#package Text::Table::Tiny;
#$Text::Table::Tiny::VERSION = '0.04';
#use parent 'Exporter';
#use List::Util qw();
#
#our @EXPORT_OK = qw/ generate_table /;
#
#
#
#our $COLUMN_SEPARATOR = '|';
#our $ROW_SEPARATOR = '-';
#our $CORNER_MARKER = '+';
#our $HEADER_ROW_SEPARATOR = '=';
#our $HEADER_CORNER_MARKER = 'O';
#
#sub generate_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";
#}
#
#*table = \&generate_table;
#
#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; 
#use 5.006;
#
#our $VERSION = '0.24';
#
#use strict;
#use warnings;
#
#use Exporter 5.57 'import';
#our @EXPORT = our @EXPORT_OK = qw(try catch finally);
#
#use Carp;
#$Carp::Internal{+__PACKAGE__}++;
#
#BEGIN {
#  my $su = $INC{'Sub/Util.pm'} && defined &Sub::Util::set_subname;
#  my $sn = $INC{'Sub/Name.pm'} && eval { Sub::Name->VERSION(0.08) };
#  unless ($su || $sn) {
#    $su = eval { require Sub::Util; } && defined &Sub::Util::set_subname;
#    unless ($su) {
#      $sn = eval { require Sub::Name; Sub::Name->VERSION(0.08) };
#    }
#  }
#
#  *_subname = $su ? \&Sub::Util::set_subname
#            : $sn ? \&Sub::Name::subname
#            : sub { $_[1] };
#  *_HAS_SUBNAME = ($su || $sn) ? sub(){1} : sub(){0};
#}
#
#
#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)
#    if _HAS_SUBNAME;
#
#  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;
#
#  my $caller = caller;
#  _subname("${caller}::catch {...} " => $block)
#    if _HAS_SUBNAME;
#  return (
#    bless(\$block, 'Try::Tiny::Catch'),
#    @rest,
#  );
#}
#
#sub finally (&;@) {
#  my ( $block, @rest ) = @_;
#
#  croak 'Useless bare finally()' unless wantarray;
#
#  my $caller = caller;
#  _subname("${caller}::finally {...} " => $block)
#    if _HAS_SUBNAME;
#  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.71';
#$VERSION = eval $VERSION;
#
#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;
#}
#
#my %require_attempted;
#
#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"}) {
#        if (not exists $require_attempted{$ic}) {
#            my $_old_error = $@;
#            eval "require $ic";
#            die $@ if $@ && $@ !~ /Can\'t locate.*in \@INC/;
#            $@ = $_old_error;
#        }
#        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 warnings;
#use base qw(Exporter);
#use vars qw($VERSION @EXPORT);
#
#$VERSION        = 20160806;
#@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 warnings;
#use base qw(URI::Find);
#
#use URI::Find ();
#
#use vars qw($VERSION);
#$VERSION = 20160806;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#
#1;
### URI/_punycode.pm ###
#package URI::_punycode;
#
#use strict;
#use warnings;
#
#our $VERSION = '1.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#use parent 'URI::http';
#
#sub default_port { 1755 }
#
#1;
### URI/news.pm ###
#package URI::news;  
#
#use strict;
#use warnings;
#
#our $VERSION = '1.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#use parent 'URI::news';
#
#1;
### URI/pop.pm ###
#package URI::pop;   
#
#use strict;
#use warnings;
#
#our $VERSION = '1.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#use parent 'URI::_login';
#
#sub default_port { 513 }
#
#1;
### URI/rsync.pm ###
#package URI::rsync;  
#
#
#use strict;
#use warnings;
#
#our $VERSION = '1.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#use parent 'URI::http';
#
#sub default_port { 554 }
#
#1;
### URI/rtspu.pm ###
#package URI::rtspu;
#
#use strict;
#use warnings;
#
#our $VERSION = '1.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#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.71';
#$VERSION = eval $VERSION;
#
#use parent 'URI::_login';
#
#sub default_port { 23 }
#
#1;
### URI/tn3270.pm ###
#package URI::tn3270;
#
#use strict;
#use warnings;
#
#our $VERSION = '1.71';
#$VERSION = eval $VERSION;
#
#use parent 'URI::_login';
#
#sub default_port { 23 }
#
#1;
### URI/urn.pm ###
#package URI::urn;  
#
#use strict;
#use warnings;
#
#our $VERSION = '1.71';
#$VERSION = eval $VERSION;
#
#use parent 'URI';
#
#use Carp qw(carp);
#
#my %implementor;
#my %require_attempted;
#
#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"}) {
#            if (not exists $require_attempted{$impclass}) {
#                my $_old_error = $@;
#                eval "require $impclass";
#                die $@ if $@ && $@ !~ /Can\'t locate.*in \@INC/;
#                $@ = $_old_error;
#            }
#	    $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.71';
#$VERSION = eval $VERSION;
#
#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__
#
### WWW/RobotRules.pm ###
#package WWW::RobotRules;
#
#$VERSION = "6.02";
#sub Version { $VERSION; }
#
#use strict;
#use URI ();
#
#
#
#sub new {
#    my($class, $ua) = @_;
#
#    $class = "WWW::RobotRules::InCore" if $class eq "WWW::RobotRules";
#
#    my $self = bless { }, $class;
#    $self->agent($ua);
#    $self;
#}
#
#
#sub parse {
#    my($self, $robot_txt_uri, $txt, $fresh_until) = @_;
#    $robot_txt_uri = URI->new("$robot_txt_uri");
#    my $netloc = $robot_txt_uri->host . ":" . $robot_txt_uri->port;
#
#    $self->clear_rules($netloc);
#    $self->fresh_until($netloc, $fresh_until || (time + 365*24*3600));
#
#    my $ua;
#    my $is_me = 0;		
#    my $is_anon = 0;		
#    my $seen_disallow = 0;      
#    my @me_disallowed = ();	
#    my @anon_disallowed = ();	
#
#    $txt =~ s/\015\012/\012/g;
#
#    for(split(/[\012\015]/, $txt)) {
#
#	next if /^\s*\#/;
#
#	s/\s*\#.*//;        
#
#	if (/^\s*$/) {	    
#	    last if $is_me; 
#	    $is_anon = 0;
#	    $seen_disallow = 0;
#	}
#        elsif (/^\s*User-Agent\s*:\s*(.*)/i) {
#	    $ua = $1;
#	    $ua =~ s/\s+$//;
#
#	    if ($seen_disallow) {
#		$seen_disallow = 0;
#		last if $is_me; 
#		$is_anon = 0;
#	    }
#
#	    if ($is_me) {
#	    }
#	    elsif ($ua eq '*') {
#		$is_anon = 1;
#	    }
#	    elsif($self->is_me($ua)) {
#		$is_me = 1;
#	    }
#	}
#	elsif (/^\s*Disallow\s*:\s*(.*)/i) {
#	    unless (defined $ua) {
#		warn "RobotRules <$robot_txt_uri>: Disallow without preceding User-agent\n" if $^W;
#		$is_anon = 1;  
#	    }
#	    my $disallow = $1;
#	    $disallow =~ s/\s+$//;
#	    $seen_disallow = 1;
#	    if (length $disallow) {
#		my $ignore;
#		eval {
#		    my $u = URI->new_abs($disallow, $robot_txt_uri);
#		    $ignore++ if $u->scheme ne $robot_txt_uri->scheme;
#		    $ignore++ if lc($u->host) ne lc($robot_txt_uri->host);
#		    $ignore++ if $u->port ne $robot_txt_uri->port;
#		    $disallow = $u->path_query;
#		    $disallow = "/" unless length $disallow;
#		};
#		next if $@;
#		next if $ignore;
#	    }
#
#	    if ($is_me) {
#		push(@me_disallowed, $disallow);
#	    }
#	    elsif ($is_anon) {
#		push(@anon_disallowed, $disallow);
#	    }
#	}
#        elsif (/\S\s*:/) {
#        }
#	else {
#	    warn "RobotRules <$robot_txt_uri>: Malformed record: <$_>\n" if $^W;
#	}
#    }
#
#    if ($is_me) {
#	$self->push_rules($netloc, @me_disallowed);
#    }
#    else {
#	$self->push_rules($netloc, @anon_disallowed);
#    }
#}
#
#
#sub is_me {
#    my($self, $ua_line) = @_;
#    my $me = $self->agent;
#
#
#    if(index(lc($me), lc($ua_line)) >= 0) {
#      return 1;
#    }
#    else {
#      return '';
#    }
#}
#
#
#sub allowed {
#    my($self, $uri) = @_;
#    $uri = URI->new("$uri");
#
#    return 1 unless $uri->scheme eq 'http' or $uri->scheme eq 'https';
#
#    my $netloc = $uri->host . ":" . $uri->port;
#
#    my $fresh_until = $self->fresh_until($netloc);
#    return -1 if !defined($fresh_until) || $fresh_until < time;
#
#    my $str = $uri->path_query;
#    my $rule;
#    for $rule ($self->rules($netloc)) {
#	return 1 unless length $rule;
#	return 0 if index($str, $rule) == 0;
#    }
#    return 1;
#}
#
#
#sub agent;
#sub visit;
#sub no_visits;
#sub last_visits;
#sub fresh_until;
#sub push_rules;
#sub clear_rules;
#sub rules;
#sub dump;
#
#
#
#package WWW::RobotRules::InCore;
#
#use vars qw(@ISA);
#@ISA = qw(WWW::RobotRules);
#
#
#
#sub agent {
#    my ($self, $name) = @_;
#    my $old = $self->{'ua'};
#    if ($name) {
#
#	$name = $1 if $name =~ m/(\S+)/; 
#	$name =~ s!/.*!!;  
#	unless ($old && $old eq $name) {
#	    delete $self->{'loc'}; 
#	    $self->{'ua'} = $name;
#	}
#    }
#    $old;
#}
#
#
#sub visit {
#    my($self, $netloc, $time) = @_;
#    return unless $netloc;
#    $time ||= time;
#    $self->{'loc'}{$netloc}{'last'} = $time;
#    my $count = \$self->{'loc'}{$netloc}{'count'};
#    if (!defined $$count) {
#	$$count = 1;
#    }
#    else {
#	$$count++;
#    }
#}
#
#
#sub no_visits {
#    my ($self, $netloc) = @_;
#    $self->{'loc'}{$netloc}{'count'};
#}
#
#
#sub last_visit {
#    my ($self, $netloc) = @_;
#    $self->{'loc'}{$netloc}{'last'};
#}
#
#
#sub fresh_until {
#    my ($self, $netloc, $fresh_until) = @_;
#    my $old = $self->{'loc'}{$netloc}{'fresh'};
#    if (defined $fresh_until) {
#	$self->{'loc'}{$netloc}{'fresh'} = $fresh_until;
#    }
#    $old;
#}
#
#
#sub push_rules {
#    my($self, $netloc, @rules) = @_;
#    push (@{$self->{'loc'}{$netloc}{'rules'}}, @rules);
#}
#
#
#sub clear_rules {
#    my($self, $netloc) = @_;
#    delete $self->{'loc'}{$netloc}{'rules'};
#}
#
#
#sub rules {
#    my($self, $netloc) = @_;
#    if (defined $self->{'loc'}{$netloc}{'rules'}) {
#	return @{$self->{'loc'}{$netloc}{'rules'}};
#    }
#    else {
#	return ();
#    }
#}
#
#
#sub dump
#{
#    my $self = shift;
#    for (keys %$self) {
#	next if $_ eq 'loc';
#	print "$_ = $self->{$_}\n";
#    }
#    for (keys %{$self->{'loc'}}) {
#	my @rules = $self->rules($_);
#	print "$_: ", join("; ", @rules), "\n";
#    }
#}
#
#
#1;
#
#__END__
#
#
## Bender: "Well, I don't have anything else
##          planned for today.  Let's get drunk!"
#
### WWW/RobotRules/AnyDBM_File.pm ###
#package WWW::RobotRules::AnyDBM_File;
#
#require  WWW::RobotRules;
#@ISA = qw(WWW::RobotRules);
#$VERSION = "6.00";
#
#use Carp ();
#use AnyDBM_File;
#use Fcntl;
#use strict;
#
#
#sub new 
#{ 
#  my ($class, $ua, $file) = @_;
#  Carp::croak('WWW::RobotRules::AnyDBM_File filename required') unless $file;
#
#  my $self = bless { }, $class;
#  $self->{'filename'} = $file;
#  tie %{$self->{'dbm'}}, 'AnyDBM_File', $file, O_CREAT|O_RDWR, 0640
#    or Carp::croak("Can't open $file: $!");
#  
#  if ($ua) {
#      $self->agent($ua);
#  }
#  else {
#      $ua = $self->{'dbm'}{"|ua-name|"};
#      Carp::croak("No agent name specified") unless $ua;
#  }
#
#  $self;
#}
#
#sub agent {
#    my($self, $newname) = @_;
#    my $old = $self->{'dbm'}{"|ua-name|"};
#    if (defined $newname) {
#	$newname =~ s!/?\s*\d+.\d+\s*$!!;  
#	unless ($old && $old eq $newname) {
#	    my $file = $self->{'filename'};
#	    untie %{$self->{'dbm'}};
#	    tie %{$self->{'dbm'}}, 'AnyDBM_File', $file, O_TRUNC|O_RDWR, 0640;
#	    %{$self->{'dbm'}} = ();
#	    $self->{'dbm'}{"|ua-name|"} = $newname;
#	}
#    }
#    $old;
#}
#
#sub no_visits {
#    my ($self, $netloc) = @_;
#    my $t = $self->{'dbm'}{"$netloc|vis"};
#    return 0 unless $t;
#    (split(/;\s*/, $t))[0];
#}
#
#sub last_visit {
#    my ($self, $netloc) = @_;
#    my $t = $self->{'dbm'}{"$netloc|vis"};
#    return undef unless $t;
#    (split(/;\s*/, $t))[1];
#}
#
#sub fresh_until {
#    my ($self, $netloc, $fresh) = @_;
#    my $old = $self->{'dbm'}{"$netloc|exp"};
#    if ($old) {
#	$old =~ s/;.*//;  
#    }
#    if (defined $fresh) {
#	$fresh .= "; " . localtime($fresh);
#	$self->{'dbm'}{"$netloc|exp"} = $fresh;
#    }
#    $old;
#}
#
#sub visit {
#    my($self, $netloc, $time) = @_;
#    $time ||= time;
#
#    my $count = 0;
#    my $old = $self->{'dbm'}{"$netloc|vis"};
#    if ($old) {
#	my $last;
#	($count,$last) = split(/;\s*/, $old);
#	$time = $last if $last > $time;
#    }
#    $count++;
#    $self->{'dbm'}{"$netloc|vis"} = "$count; $time; " . localtime($time);
#}
#
#sub push_rules {
#    my($self, $netloc, @rules) = @_;
#    my $cnt = 1;
#    $cnt++ while $self->{'dbm'}{"$netloc|r$cnt"};
#
#    foreach (@rules) {
#	$self->{'dbm'}{"$netloc|r$cnt"} = $_;
#	$cnt++;
#    }
#}
#
#sub clear_rules {
#    my($self, $netloc) = @_;
#    my $cnt = 1;
#    while ($self->{'dbm'}{"$netloc|r$cnt"}) {
#	delete $self->{'dbm'}{"$netloc|r$cnt"};
#	$cnt++;
#    }
#}
#
#sub rules {
#    my($self, $netloc) = @_;
#    my @rules = ();
#    my $cnt = 1;
#    while (1) {
#	my $rule = $self->{'dbm'}{"$netloc|r$cnt"};
#	last unless $rule;
#	push(@rules, $rule);
#	$cnt++;
#    }
#    @rules;
#}
#
#sub dump
#{
#}
#
#1;
#
#
### YAML.pm ###
#package YAML;
#our $VERSION = '1.18';
#
#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.18';
#
#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;
#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};*{$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->(@_)}}};*{$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->(@_)}}};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/Old.pm ###
#use strict; use warnings;
#package YAML::Old;
#our $VERSION = '1.07';
#
#use YAML::Old::Mo;
#
#use Exporter;
#push @YAML::Old::ISA, 'Exporter';
#our @EXPORT = qw{ Dump Load };
#our @EXPORT_OK = qw{ freeze thaw DumpFile LoadFile Bless Blessed };
#
#use YAML::Old::Node; 
#
#{
#    package
#    YAML;
#    use constant VALUE => "\x07YAML\x07VALUE\x07";
#}
#
#has dumper_class => default => sub {'YAML::Old::Dumper'};
#has loader_class => default => sub {'YAML::Old::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::Old->new;
#    $yaml->dumper_class($YAML::Old::DumperClass)
#        if $YAML::Old::DumperClass;
#    return $yaml->dumper_object->dump(@_);
#}
#
#sub Load {
#    my $yaml = YAML::Old->new;
#    $yaml->loader_class($YAML::Old::LoaderClass)
#        if $YAML::Old::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::Old::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::Old::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::Old::Dumper::Base;
#    YAML::Old::Dumper::Base::bless($global, @_)
#}
#sub Blessed {
#    require YAML::Old::Dumper::Base;
#    YAML::Old::Dumper::Base::blessed($global, @_)
#}
#sub global_object { $global }
#
#1;
### YAML/Old/Dumper.pm ###
#package YAML::Old::Dumper;
#
#use YAML::Old::Mo;
#extends 'YAML::Old::Dumper::Base';
#
#use YAML::Old::Dumper::Base;
#use YAML::Old::Node;
#use YAML::Old::Types;
#
#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::Old::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::Old::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::Old::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::Old::Type::blessed->yaml_dump($value);
#        }
#        $self->transferred->{$node_id} = $value;
#        (undef, $type, $node_id) = $self->node_info($value, $stringify);
#    }
#
#    require YAML::Old;
#    if (defined YAML::Old->global_object()->{blessed_map}{$node_id}) {
#        $value = YAML::Old->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::Old::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::Old::Type::ref->yaml_dump($value);
#
#        my $glob_ynode = $ref_ynode->{&VALUE} =
#          YAML::Old::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::Old::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_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_valid_plain {
#    my $self = shift;
#    return 0 unless length $_[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/Old/Dumper/Base.pm ###
#package YAML::Old::Dumper::Base;
#
#use YAML::Old::Mo;
#
#use YAML::Old::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 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;
#}
#
#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::Old::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::Old::Mo::Object->node_info($ref);
#    if (not defined $blessing) {
#        $ynode = YAML::Old::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/Old/Error.pm ###
#package YAML::Old::Error;
#
#use YAML::Old::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_NO_FINAL_NEWLINE
#  Stream does not end with newline character
#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::Old::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::Old::Warning;
#
#our @ISA = 'YAML::Old::Error';
#
#1;
### YAML/Old/Loader.pm ###
#package YAML::Old::Loader;
#
#use YAML::Old::Mo;
#extends 'YAML::Old::Loader::Base';
#
#use YAML::Old::Loader::Base;
#use YAML::Old::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->die('YAML_PARSE_ERR_NO_FINAL_NEWLINE')
#      if length($self->stream) and
#         $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::Old::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::Old::TagClass->{$explicit} ||
#           $explicit =~ m{^perl/(\@|\$)?([a-zA-Z](\w|::)+)$}
#          ) {
#        $class = $YAML::Old::TagClass->{$explicit} || $2;
#        if ($class->can('yaml_load')) {
#            require YAML::Old::Node;
#            return $class->yaml_load(YAML::Old::Node->new($node, $explicit));
#        }
#        else {
#            if (ref $node) {
#                return CORE::bless $node, $class;
#            }
#            else {
#                return CORE::bless \$node, $class;
#            }
#        }
#    }
#    elsif (ref $node) {
#        require YAML::Old::Node;
#        return YAML::Old::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] =~ /^( *)/ or die;
#                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 die;
#            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/Old/Loader/Base.pm ###
#package YAML::Old::Loader::Base;
#
#use YAML::Old::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/Old/Marshall.pm ###
#use strict; use warnings;
#package YAML::Old::Marshall;
#
#use YAML::Old::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::Old::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::Old::Node->new(@_);
#}
#
#sub yaml_ynode {
#    shift;
#    YAML::Old::Node::ynode(@_);
#}
#
#1;
### YAML/Old/Mo.pm ###
#package YAML::Old::Mo;
#
#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::Old::Error;
#
#    my $code = shift || 'unknown error';
#    my $error = YAML::Old::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/Old/Node.pm ###
#use strict; use warnings;
#package YAML::Old::Node;
#
#use YAML::Old::Tag;
#require YAML::Old::Mo;
#
#use Exporter;
#our @ISA     = qw(Exporter YAML::Old::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::Old::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::Old::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::Old::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::Old::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::Old::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::Old::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/Old/Tag.pm ###
#use strict; use warnings;
#package YAML::Old::Tag;
#
#use overload '""' => sub { ${$_[0]} };
#
#sub new {
#    my ($class, $self) = @_;
#    bless \$self, $class
#}
#
#sub short {
#    ${$_[0]}
#}
#
#sub canonical {
#    ${$_[0]}
#}
#
#1;
### YAML/Old/Types.pm ###
#package YAML::Old::Types;
#
#use YAML::Old::Mo;
#use YAML::Old::Node;
#
#package YAML::Old::Type::blessed;
#
#use YAML::Old::Mo; 
#
#sub yaml_dump {
#    my $self = shift;
#    my ($value) = @_;
#    my ($class, $type) = YAML::Old::Mo::Object->node_info($value);
#    no strict 'refs';
#    my $kind = lc($type) . ':';
#    my $tag = ${$class . '::ClassTag'} ||
#              "!perl/$kind$class";
#    if ($type eq 'REF') {
#        YAML::Old::Node->new(
#            {(&YAML::VALUE, ${$_[0]})}, $tag
#        );
#    }
#    elsif ($type eq 'SCALAR') {
#        $_[1] = $$value;
#        YAML::Old::Node->new($_[1], $tag);
#    } else {
#        YAML::Old::Node->new($value, $tag);
#    }
#}
#
#package YAML::Old::Type::undef;
#
#sub yaml_dump {
#    my $self = shift;
#}
#
#sub yaml_load {
#    my $self = shift;
#}
#
#package YAML::Old::Type::glob;
#
#sub yaml_dump {
#    my $self = shift;
#    my $ynode = YAML::Old::Node->new({}, '!perl/glob:');
#    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::Old::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::Old::Type::code;
#
#my $dummy_warned = 0;
#my $default = '{ "DUMMY" }';
#
#sub yaml_dump {
#    my $self = shift;
#    my $code;
#    my ($dumpflag, $value) = @_;
#    my ($class, $type) = YAML::Old::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::Old::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::Old::Type::ref;
#
#sub yaml_dump {
#    my $self = shift;
#    YAML::Old::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::Old::Type::regexp;
#
#sub yaml_dump {
#    die "YAML::Old::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;
### 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.016';
#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',
#	bitwise         => '5.22.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.22.0',
#	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',
#);
#my %max_version = (
#	lexical_topic   => '5.23.4',
#);
#
#$_ = version->new($_) for values %min_version;
#$_ = version->new($_) for values %max_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";
#	}
#	elsif ($] >= ($max_version{$pragma} || 7)) {
#		croak "Experimental feature $pragma has been removed from perl in version $max_version{$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.27';
#$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 & 0x01
#            &&
#          defined &DB::sub
#            &&
#          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;
#        }
#
#        on_scope_end {
#            $RemoveSubs->($cleanee, $store, keys %{ $store->{remove} });
#        };
#
#        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 qw(_load_module);
#
#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__
#
### strictures.pm ###
#package strictures;
#
#use strict;
#use warnings FATAL => 'all';
#
#BEGIN {
#  *_PERL_LT_5_8_4 = ($] < 5.008004) ? sub(){1} : sub(){0};
#  *_CAN_GOTO_VERSION = ($] >= 5.010000) ? sub(){1} : sub(){0};
#}
#
#our $VERSION = '2.000003';
#$VERSION = eval $VERSION;
#
#our @WARNING_CATEGORIES = grep { exists $warnings::Offsets{$_} } qw(
#  closure
#  chmod
#  deprecated
#  exiting
#  experimental
#    experimental::autoderef
#    experimental::bitwise
#    experimental::const_attr
#    experimental::lexical_subs
#    experimental::lexical_topic
#    experimental::postderef
#    experimental::re_strict
#    experimental::refaliasing
#    experimental::regex_sets
#    experimental::signatures
#    experimental::smartmatch
#    experimental::win32_perlio
#  glob
#  imprecision
#  io
#    closed
#    exec
#    layer
#    newline
#    pipe
#    syscalls
#    unopened
#  locale
#  misc
#  missing
#  numeric
#  once
#  overflow
#  pack
#  portable
#  recursion
#  redefine
#  redundant
#  regexp
#  severe
#    debugging
#    inplace
#    internal
#    malloc
#  signal
#  substr
#  syntax
#    ambiguous
#    bareword
#    digit
#    illegalproto
#    parenthesis
#    precedence
#    printf
#    prototype
#    qw
#    reserved
#    semicolon
#  taint
#  threads
#  uninitialized
#  umask
#  unpack
#  untie
#  utf8
#    non_unicode
#    nonchar
#    surrogate
#  void
#  void_unusual
#  y2k
#);
#
#sub VERSION {
#  {
#    no warnings;
#    local $@;
#    if (defined $_[1] && eval { &UNIVERSAL::VERSION; 1}) {
#      $^H |= 0x20000
#        unless _PERL_LT_5_8_4;
#      $^H{strictures_enable} = int $_[1];
#    }
#  }
#  _CAN_GOTO_VERSION ? goto &UNIVERSAL::VERSION : &UNIVERSAL::VERSION;
#}
#
#our %extra_load_states;
#
#our $Smells_Like_VCS;
#
#sub import {
#  my $class = shift;
#  my %opts = @_ == 1 ? %{$_[0]} : @_;
#  if (!exists $opts{version}) {
#    $opts{version}
#      = exists $^H{strictures_enable} ? delete $^H{strictures_enable}
#      : int $VERSION;
#  }
#  $opts{file} = (caller)[1];
#  $class->_enable(\%opts);
#}
#
#sub _enable {
#  my ($class, $opts) = @_;
#  my $version = $opts->{version};
#  $version = 'undef'
#    if !defined $version;
#  my $method = "_enable_$version";
#  if (!$class->can($method)) {
#    require Carp;
#    Carp::croak("Major version specified as $version - not supported!");
#  }
#  $class->$method($opts);
#}
#
#sub _enable_1 {
#  my ($class, $opts) = @_;
#  strict->import;
#  warnings->import(FATAL => 'all');
#
#  if (_want_extra($opts->{file})) {
#    _load_extras(qw(indirect multidimensional bareword::filehandles));
#    indirect->unimport(':fatal')
#      if $extra_load_states{indirect};
#    multidimensional->unimport
#      if $extra_load_states{multidimensional};
#    bareword::filehandles->unimport
#      if $extra_load_states{'bareword::filehandles'};
#  }
#}
#
#our @V2_NONFATAL = grep { exists $warnings::Offsets{$_} } (
#  'exec',         
#  'recursion',    
#  'internal',     
#  'malloc',       
#  'newline',      
#  'experimental', 
#  'deprecated',   
#  'portable',     
#);
#our @V2_DISABLE = grep { exists $warnings::Offsets{$_} } (
#  'once'          
#);
#
#sub _enable_2 {
#  my ($class, $opts) = @_;
#  strict->import;
#  warnings->import;
#  warnings->import(FATAL => @WARNING_CATEGORIES);
#  warnings->unimport(FATAL => @V2_NONFATAL);
#  warnings->import(@V2_NONFATAL);
#  warnings->unimport(@V2_DISABLE);
#
#  if (_want_extra($opts->{file})) {
#    _load_extras(qw(indirect multidimensional bareword::filehandles));
#    indirect->unimport(':fatal')
#      if $extra_load_states{indirect};
#    multidimensional->unimport
#      if $extra_load_states{multidimensional};
#    bareword::filehandles->unimport
#      if $extra_load_states{'bareword::filehandles'};
#  }
#}
#
#sub _want_extra_env {
#  if (exists $ENV{PERL_STRICTURES_EXTRA}) {
#    if (_PERL_LT_5_8_4 and $ENV{PERL_STRICTURES_EXTRA}) {
#      die 'PERL_STRICTURES_EXTRA checks are not available on perls older'
#        . "than 5.8.4: please unset \$ENV{PERL_STRICTURES_EXTRA}\n";
#    }
#    return $ENV{PERL_STRICTURES_EXTRA} ? 1 : 0;
#  }
#  return undef;
#}
#
#sub _want_extra {
#  my $file = shift;
#  my $want_env = _want_extra_env();
#  return $want_env
#    if defined $want_env;
#  return (
#    !_PERL_LT_5_8_4
#    and $file =~ /^(?:t|xt|lib|blib)[\\\/]/
#    and defined $Smells_Like_VCS ? $Smells_Like_VCS
#      : ( $Smells_Like_VCS = !!(
#        -e '.git' || -e '.svn' || -e '.hg' || -e '.bzr'
#        || (-e '../../dist.ini'
#          && (-e '../../.git' || -e '../../.svn' || -e '../../.hg' || -e '../../.bzr' ))
#      ))
#  );
#}
#
#sub _load_extras {
#  my @extras = @_;
#  my @failed;
#  foreach my $mod (@extras) {
#    next
#      if exists $extra_load_states{$mod};
#
#    $extra_load_states{$mod} = eval "require $mod; 1;" or do {
#      push @failed, $mod;
#
#      (my $file = $mod) =~ s|::|/|g;
#      delete $INC{"${file}.pm"};
#    };
#  }
#
#  if (@failed) {
#    my $failed = join ' ', @failed;
#    my $extras = join ' ', @extras;
#    print STDERR <<EOE;
#strictures.pm extra testing active but couldn't load all modules. Missing were:
#
#  $failed
#
#Extra testing is auto-enabled in checkouts only, so if you're the author
#of a strictures-using module you need to run:
#
#  cpan $extras
#
#but these modules are not required by your users.
#EOE
#  }
#}
#
#1;
#
#__END__
### strictures/extra.pm ###
#package strictures::extra;
#use strict;
#use warnings FATAL => 'all';
#
#sub import {
#  $ENV{PERL_STRICTURES_EXTRA} = 1;
#}
#
#sub unimport {
#  $ENV{PERL_STRICTURES_EXTRA} = 0;
#}
#
#1;
#
#__END__
