
=head1 NAME

perl5db.pl - the perl debugger

=head1 SYNOPSIS

    perl -d  your_Perl_script

=head1 DESCRIPTION

C<perl5db.pl> is the perl debugger. It is loaded automatically by Perl when
you invoke a script with S<C<perl -d>>. This documentation tries to outline the
structure and services provided by C<perl5db.pl>, and to describe how you
can use them.

See L<perldebug> for an overview of how to use the debugger.

=head1 GENERAL NOTES

The debugger can look pretty forbidding to many Perl programmers. There are
a number of reasons for this, many stemming out of the debugger's history.

When the debugger was first written, Perl didn't have a lot of its nicer
features - no references, no lexical variables, no closures, no object-oriented
programming. So a lot of the things one would normally have done using such
features was done using global variables, globs and the C<local()> operator
in creative ways.

Some of these have survived into the current debugger; a few of the more
interesting and still-useful idioms are noted in this section, along with notes
on the comments themselves.

=head2 Why not use more lexicals?

Experienced Perl programmers will note that the debugger code tends to use
mostly package globals rather than lexically-scoped variables. This is done
to allow a significant amount of control of the debugger from outside the
debugger itself.

Unfortunately, though the variables are accessible, they're not well
documented, so it's generally been a decision that hasn't made a lot of
difference to most users. Where appropriate, comments have been added to
make variables more accessible and usable, with the understanding that these
I<are> debugger internals, and are therefore subject to change. Future
development should probably attempt to replace the globals with a well-defined
API, but for now, the variables are what we've got.

=head2 Automated variable stacking via C<local()>

As you may recall from reading C<perlfunc>, the C<local()> operator makes a
temporary copy of a variable in the current scope. When the scope ends, the
old copy is restored. This is often used in the debugger to handle the
automatic stacking of variables during recursive calls:

     sub foo {
        local $some_global++;

        # Do some stuff, then ...
        return;
     }

What happens is that on entry to the subroutine, C<$some_global> is localized,
then altered. When the subroutine returns, Perl automatically undoes the
localization, restoring the previous value. Voila, automatic stack management.

The debugger uses this trick a I<lot>. Of particular note is C<DB::eval>,
which lets the debugger get control inside of C<eval>'ed code. The debugger
localizes a saved copy of C<$@> inside the subroutine, which allows it to
keep C<$@> safe until it C<DB::eval> returns, at which point the previous
value of C<$@> is restored. This makes it simple (well, I<simpler>) to keep
track of C<$@> inside C<eval>s which C<eval> other C<eval's>.

In any case, watch for this pattern. It occurs fairly often.

=head2 The C<^> trick

This is used to cleverly reverse the sense of a logical test depending on
the value of an auxiliary variable. For instance, the debugger's C<S>
(search for subroutines by pattern) allows you to negate the pattern
like this:

   # Find all non-'foo' subs:
   S !/foo/

Boolean algebra states that the truth table for XOR looks like this:

=over 4

=item * 0 ^ 0 = 0

(! not present and no match) --> false, don't print

=item * 0 ^ 1 = 1

(! not present and matches) --> true, print

=item * 1 ^ 0 = 1

(! present and no match) --> true, print

=item * 1 ^ 1 = 0

(! present and matches) --> false, don't print

=back

As you can see, the first pair applies when C<!> isn't supplied, and
the second pair applies when it is. The XOR simply allows us to
compact a more complicated if-then-elseif-else into a more elegant
(but perhaps overly clever) single test. After all, it needed this
explanation...

=head2 FLAGS, FLAGS, FLAGS

There is a certain C programming legacy in the debugger. Some variables,
such as C<$single>, C<$trace>, and C<$frame>, have I<magical> values composed
of 1, 2, 4, etc. (powers of 2) OR'ed together. This allows several pieces
of state to be stored independently in a single scalar.

A test like

    if ($scalar & 4) ...

is checking to see if the appropriate bit is on. Since each bit can be
"addressed" independently in this way, C<$scalar> is acting sort of like
an array of bits. Obviously, since the contents of C<$scalar> are just a
bit-pattern, we can save and restore it easily (it will just look like
a number).

The problem, is of course, that this tends to leave magic numbers scattered
all over your program whenever a bit is set, cleared, or checked. So why do
it?

=over 4

=item *

First, doing an arithmetical or bitwise operation on a scalar is
just about the fastest thing you can do in Perl: S<C<use constant>> actually
creates a subroutine call, and array and hash lookups are much slower. Is
this over-optimization at the expense of readability? Possibly, but the
debugger accesses these  variables a I<lot>. Any rewrite of the code will
probably have to benchmark alternate implementations and see which is the
best balance of readability and speed, and then document how it actually
works.

=item *

Second, it's very easy to serialize a scalar number. This is done in
the restart code; the debugger state variables are saved in C<%ENV> and then
restored when the debugger is restarted. Having them be just numbers makes
this trivial.

=item *

Third, some of these variables are being shared with the Perl core
smack in the middle of the interpreter's execution loop. It's much faster for
a C program (like the interpreter) to check a bit in a scalar than to access
several different variables (or a Perl array).

=back

=head2 What are those C<XXX> comments for?

Any comment containing C<XXX> means that the comment is either somewhat
speculative - it's not exactly clear what a given variable or chunk of
code is doing, or that it is incomplete - the basics may be clear, but the
subtleties are not completely documented.

Send in a patch if you can clear up, fill out, or clarify an C<XXX>.

=head1 DATA STRUCTURES MAINTAINED BY CORE

There are a number of special data structures provided to the debugger by
the Perl interpreter.

The array C<@{$main::{'_<'.$filename}}> (aliased locally to C<@dbline>
via glob assignment) contains the text from C<$filename>, with each
element corresponding to a single line of C<$filename>. Additionally,
breakable lines will be dualvars with the numeric component being the
memory address of a COP node. Non-breakable lines are dualvar to 0.

The hash C<%{'_<'.$filename}> (aliased locally to C<%dbline> via glob
assignment) contains breakpoints and actions.  The keys are line numbers;
you can set individual values, but not the whole hash. The Perl interpreter
uses this hash to determine where breakpoints have been set. Any true value is
considered to be a breakpoint; C<perl5db.pl> uses C<$break_condition\0$action>.
Values are magical in numeric context: 1 if the line is breakable, 0 if not.

The scalar C<${"_<$filename"}> simply contains the string C<$filename>.
This is also the case for evaluated strings that contain subroutines, or
which are currently being executed.  The $filename for C<eval>ed strings looks
like S<C<(eval 34)>>.

=head1 DEBUGGER STARTUP

When C<perl5db.pl> starts, it reads an rcfile (C<perl5db.ini> for
non-interactive sessions, C<.perldb> for interactive ones) that can set a number
of options. In addition, this file may define a subroutine C<&afterinit>
that will be executed (in the debugger's context) after the debugger has
initialized itself.

Next, it checks the C<PERLDB_OPTS> environment variable and treats its
contents as the argument of a C<o> command in the debugger.

=head2 STARTUP-ONLY OPTIONS

The following options can only be specified at startup.
To set them in your rcfile, add a call to
C<&parse_options("optionName=new_value")>.

=over 4

=item * TTY

the TTY to use for debugging i/o.

=item * noTTY

if set, goes in NonStop mode.  On interrupt, if TTY is not set,
uses the value of noTTY or F<$HOME/.perldbtty$$> to find TTY using
Term::Rendezvous.  Current variant is to have the name of TTY in this
file.

=item * ReadLine

if false, a dummy ReadLine is used, so you can debug
ReadLine applications.

=item * NonStop

if true, no i/o is performed until interrupt.

=item * LineInfo

file or pipe to print line number info to.  If it is a
pipe, a short "emacs like" message is used.

=item * RemotePort

host:port to connect to on remote host for remote debugging.

=item * HistFile

file to store session history to. There is no default and so no
history file is written unless this variable is explicitly set.

=item * HistSize

number of commands to store to the file specified in C<HistFile>.
Default is 100.

=back

=head3 SAMPLE RCFILE

 &parse_options("NonStop=1 LineInfo=db.out");
  sub afterinit { $trace = 1; }

The script will run without human intervention, putting trace
information into C<db.out>.  (If you interrupt it, you had better
reset C<LineInfo> to something I<interactive>!)

=head1 INTERNALS DESCRIPTION

=head2 DEBUGGER INTERFACE VARIABLES

Perl supplies the values for C<%sub>.  It effectively inserts
a C<&DB::DB();> in front of each place that can have a
breakpoint. At each subroutine call, it calls C<&DB::sub> with
C<$DB::sub> set to the called subroutine. It also inserts a C<BEGIN
{require 'perl5db.pl'}> before the first line.

After each C<require>d file is compiled, but before it is executed, a
call to C<&DB::postponed($main::{'_<'.$filename})> is done. C<$filename>
is the expanded name of the C<require>d file (as found via C<%INC>).

=head3 IMPORTANT INTERNAL VARIABLES

=head4 C<$CreateTTY>

Used to control when the debugger will attempt to acquire another TTY to be
used for input.

=over

=item * 1 -  on C<fork()>

=item * 2 - debugger is started inside debugger

=item * 4 -  on startup

=back

=head4 C<$doret>

The value -2 indicates that no return value should be printed.
Any other positive value causes C<DB::sub> to print return values.

=head4 C<$evalarg>

The item to be eval'ed by C<DB::eval>. Used to prevent messing with the current
contents of C<@_> when C<DB::eval> is called.

=head4 C<$frame>

Determines what messages (if any) will get printed when a subroutine (or eval)
is entered or exited.

=over 4

=item * 0 -  No enter/exit messages

=item * 1 - Print I<entering> messages on subroutine entry

=item * 2 - Adds exit messages on subroutine exit. If no other flag is on, acts like 1+2.

=item * 4 - Extended messages: C<< <in|out> I<context>=I<fully-qualified sub name> from I<file>:I<line> >>. If no other flag is on, acts like 1+4.

=item * 8 - Adds parameter information to messages, and overloaded stringify and tied FETCH is enabled on the printed arguments. Ignored if C<4> is not on.

=item * 16 - Adds C<I<context> return from I<subname>: I<value>> messages on subroutine/eval exit. Ignored if C<4> is not on.

=back

To get everything, use C<$frame=30> (or S<C<o f=30>> as a debugger command).
The debugger internally juggles the value of C<$frame> during execution to
protect external modules that the debugger uses from getting traced.

=head4 C<$level>

Tracks current debugger nesting level. Used to figure out how many
C<E<lt>E<gt>> pairs to surround the line number with when the debugger
outputs a prompt. Also used to help determine if the program has finished
during command parsing.

=head4 C<$onetimeDump>

Controls what (if anything) C<DB::eval()> will print after evaluating an
expression.

=over 4

=item * C<undef> - don't print anything

=item * C<dump> - use C<dumpvar.pl> to display the value returned

=item * C<methods> - print the methods callable on the first item returned

=back

=head4 C<$onetimeDumpDepth>

Controls how far down C<dumpvar.pl> will go before printing C<...> while
dumping a structure. Numeric. If C<undef>, print all levels.

=head4 C<$signal>

Used to track whether or not an C<INT> signal has been detected. C<DB::DB()>,
which is called before every statement, checks this and puts the user into
command mode if it finds C<$signal> set to a true value.

=head4 C<$single>

Controls behavior during single-stepping. Stacked in C<@stack> on entry to
each subroutine; popped again at the end of each subroutine.

=over 4

=item * 0 - run continuously.

=item * 1 - single-step, go into subs. The C<s> command.

=item * 2 - single-step, don't go into subs. The C<n> command.

=item * 4 - print current sub depth (turned on to force this when C<too much
recursion> occurs.

=back

=head4 C<$trace>

Controls the output of trace information.

=over 4

=item * 1 - The C<t> command was entered to turn on tracing (every line executed is printed)

=item * 2 - watch expressions are active

=item * 4 - user defined a C<watchfunction()> in C<afterinit()>

=back

=head4 C<$client_editor>

1 if C<LINEINFO> was directed to a pipe; 0 otherwise.  (The term
C<$slave_editor> was formerly used here.)

=head4 C<@cmdfhs>

Stack of filehandles that C<DB::readline()> will read commands from.
Manipulated by the debugger's C<source> command and C<DB::readline()> itself.

=head4 C<@dbline>

Local alias to the magical line array, C<@{$main::{'_<'.$filename}}> ,
supplied by the Perl interpreter to the debugger. Contains the source.

=head4 C<@old_watch>

Previous values of watch expressions. First set when the expression is
entered; reset whenever the watch expression changes.

=head4 C<@saved>

Saves important globals (C<$@>, C<$!>, C<$^E>, C<$,>, C<$/>, C<$\>, C<$^W>)
so that the debugger can substitute safe values while it's running, and
restore them when it returns control.

=head4 C<@stack>

Saves the current value of C<$single> on entry to a subroutine.
Manipulated by the C<c> command to turn off tracing in all subs above the
current one.

=head4 C<@to_watch>

The 'watch' expressions: to be evaluated before each line is executed.

=head4 C<@typeahead>

The typeahead buffer, used by C<DB::readline>.

=head4 C<%alias>

Command aliases. Stored as character strings to be substituted for a command
entered.

=head4 C<%break_on_load>

Keys are file names, values are 1 (break when this file is loaded) or undef
(don't break when it is loaded).

=head4 C<%dbline>

Keys are line numbers, values are C<condition\0action>. If used in numeric
context, values are 0 if not breakable, 1 if breakable, no matter what is
in the actual hash entry.

=head4 C<%had_breakpoints>

Keys are file names; values are bitfields:

=over 4

=item * 1 - file has a breakpoint in it.

=item * 2 - file has an action in it.

=back

A zero or undefined value means this file has neither.

=head4 C<%option>

Stores the debugger options. These are character string values.

=head4 C<%postponed>

Saves breakpoints for code that hasn't been compiled yet.
Keys are subroutine names, values are:

=over 4

=item * C<compile> - break when this sub is compiled

=item * C<< break +0 if <condition> >> - break (conditionally) at the start of this routine. The condition will be '1' if no condition was specified.

=back

=head4 C<%postponed_file>

This hash keeps track of breakpoints that need to be set for files that have
not yet been compiled. Keys are filenames; values are references to hashes.
Each of these hashes is keyed by line number, and its values are breakpoint
definitions (C<condition\0action>).

=head1 DEBUGGER INITIALIZATION

The debugger's initialization actually jumps all over the place inside this
package. This is because there are several BEGIN blocks (which of course
execute immediately) spread through the code. Why is that?

The debugger needs to be able to change some things and set some things up
before the debugger code is compiled; most notably, the C<$deep> variable that
C<DB::sub> uses to tell when a program has recursed deeply. In addition, the
debugger has to turn off warnings while the debugger code is compiled, but then
restore them to their original setting before the program being debugged begins
executing.

The first C<BEGIN> block simply turns off warnings by saving the current
setting of C<$^W> and then setting it to zero. The second one initializes
the debugger variables that are needed before the debugger begins executing.
The third one puts C<$^X> back to its former value.

We'll detail the second C<BEGIN> block later; just remember that if you need
to initialize something before the debugger starts really executing, that's
where it has to go.

=cut

package DB;

use strict;

use Cwd ();

my $_initial_cwd;

BEGIN {eval 'use IO::Handle'}; # Needed for flush only? breaks under miniperl

BEGIN {
    require feature;
    $^V =~ /^v(\d+\.\d+)/;
    feature->import(":$1");
    $_initial_cwd = Cwd::getcwd();
}

# Debugger for Perl 5.00x; perl5db.pl patch level:
use vars qw($VERSION $header);

# bump to X.XX in blead, only use X.XX_XX in maint
$VERSION = '1.73';

$header = "perl5db.pl version $VERSION";

=head1 DEBUGGER ROUTINES

=head2 C<DB::eval()>

This function replaces straight C<eval()> inside the debugger; it simplifies
the process of evaluating code in the user's context.

The code to be evaluated is passed via the package global variable
C<$DB::evalarg>; this is done to avoid fiddling with the contents of C<@_>.

Before we do the C<eval()>, we preserve the current settings of C<$trace>,
C<$single>, C<$^D> and C<$usercontext>.  The latter contains the
preserved values of C<$@>, C<$!>, C<$^E>, C<$,>, C<$/>, C<$\>, C<$^W> and the
user's current package, grabbed when C<DB::DB> got control.  This causes the
proper context to be used when the eval is actually done.  Afterward, we
restore C<$trace>, C<$single>, and C<$^D>.

Next we need to handle C<$@> without getting confused. We save C<$@> in a
local lexical, localize C<$saved[0]> (which is where C<save()> will put
C<$@>), and then call C<save()> to capture C<$@>, C<$!>, C<$^E>, C<$,>,
C<$/>, C<$\>, and C<$^W>) and set C<$,>, C<$/>, C<$\>, and C<$^W> to values
considered sane by the debugger. If there was an C<eval()> error, we print
it on the debugger's output. If C<$onetimedump> is defined, we call
C<dumpit> if it's set to 'dump', or C<methods> if it's set to
'methods'. Setting it to something else causes the debugger to do the eval
but not print the result - handy if you want to do something else with it
(the "watch expressions" code does this to get the value of the watch
expression but not show it unless it matters).

In any case, we then return the list of output from C<eval> to the caller,
and unwinding restores the former version of C<$@> in C<@saved> as well
(the localization of C<$saved[0]> goes away at the end of this scope).

=head3 Parameters and variables influencing execution of DB::eval()

C<DB::eval> isn't parameterized in the standard way; this is to keep the
debugger's calls to C<DB::eval()> from mucking with C<@_>, among other things.
The variables listed below influence C<DB::eval()>'s execution directly.

=over 4

=item C<$evalarg> - the thing to actually be eval'ed

=item C<$trace> - Current state of execution tracing

=item C<$single> - Current state of single-stepping

=item C<$onetimeDump> - what is to be displayed after the evaluation

=item C<$onetimeDumpDepth> - how deep C<dumpit()> should go when dumping results

=back

The following variables are altered by C<DB::eval()> during its execution. They
are "stacked" via C<local()>, enabling recursive calls to C<DB::eval()>.

=over 4

=item C<@res> - used to capture output from actual C<eval>.

=item C<$otrace> - saved value of C<$trace>.

=item C<$osingle> - saved value of C<$single>.

=item C<$od> - saved value of C<$^D>.

=item C<$saved[0]> - saved value of C<$@>.

=item $\ - for output of C<$@> if there is an evaluation error.

=back

=head3 The problem of lexicals

The context of C<DB::eval()> presents us with some problems. Obviously,
we want to be 'sandboxed' away from the debugger's internals when we do
the eval, but we need some way to control how punctuation variables and
debugger globals are used.

We can't use local, because the code inside C<DB::eval> can see localized
variables; and we can't use C<my> either for the same reason. The code
in this routine compromises and uses C<my>.

After this routine is over, we don't have user code executing in the debugger's
context, so we can use C<my> freely.

=cut

############################################## Begin lexical danger zone

# 'my' variables used here could leak into (that is, be visible in)
# the context that the code being evaluated is executing in. This means that
# the code could modify the debugger's variables.
#
# Fiddling with the debugger's context could be Bad. We insulate things as
# much as we can.

use vars qw(
    @args
    %break_on_load
    $CommandSet
    $CreateTTY
    $DBGR
    @dbline
    $dbline
    %dbline
    $dieLevel
    $filename
    $histfile
    $histsize
    $histitemminlength
    $IN
    $inhibit_exit
    @ini_INC
    $ini_warn
    $maxtrace
    $od
    @options
    $osingle
    $otrace
    $pager
    $post
    %postponed
    $prc
    $pre
    $pretype
    $psh
    @RememberOnROptions
    $remoteport
    @res
    $rl
    @saved
    $signalLevel
    $sub
    $term
    $usercontext
    $warnLevel
);

our (
    @cmdfhs,
    $evalarg,
    $frame,
    $hist,
    $ImmediateStop,
    $line,
    $onetimeDump,
    $onetimedumpDepth,
    %option,
    $OUT,
    $packname,
    $signal,
    $single,
    $start,
    %sub,
    $subname,
    $trace,
    $window,
);

# Used to save @ARGV and extract any debugger-related flags.
use vars qw(@ARGS);

# Used to prevent multiple entries to diesignal()
# (if for instance diesignal() itself dies)
use vars qw($panic);

# Used to prevent the debugger from running nonstop
# after a restart
our ($second_time);

sub _calc_usercontext {
    my ($package) = @_;

    # Cancel strict completely for the evaluated code, so the code
    # the user evaluates won't be affected by it. (Shlomi Fish)
    return 'no strict; ($@, $!, $^E, $,, $/, $\, $^W) = @DB::saved;'
    . "package $package;";    # this won't let them modify, alas
}

sub eval {

    # 'my' would make it visible from user code
    #    but so does local! --tchrist
    # Remember: this localizes @DB::res, not @main::res.
    local @res;
    {

        # Try to keep the user code from messing  with us. Save these so that
        # even if the eval'ed code changes them, we can put them back again.
        # Needed because the user could refer directly to the debugger's
        # package globals (and any 'my' variables in this containing scope)
        # inside the eval(), and we want to try to stay safe.
        local $otrace  = $trace;
        local $osingle = $single;
        local $od      = $^D;

        # Untaint the incoming eval() argument.
        { ($evalarg) = $evalarg =~ /(.*)/s; }

        # $usercontext built in DB::DB near the comment
        # "set up the context for DB::eval ..."
        # Evaluate and save any results.
        @res = eval "$usercontext $evalarg;\n";  # '\n' for nice recursive debug

        # Restore those old values.
        $trace  = $otrace;
        $single = $osingle;
        $^D     = $od;
    }

    # Save the current value of $@, and preserve it in the debugger's copy
    # of the saved precious globals.
    my $at = $@;

    # Since we're only saving $@, we only have to localize the array element
    # that it will be stored in.
    local $saved[0];    # Preserve the old value of $@
    eval { &DB::save };

    # Now see whether we need to report an error back to the user.
    if ($at) {
        local $\ = '';
        print $OUT $at;
    }

    # Display as required by the caller. $onetimeDump and $onetimedumpDepth
    # are package globals.
    elsif ($onetimeDump) {
        if ( $onetimeDump eq 'dump' ) {
            local $option{dumpDepth} = $onetimedumpDepth
              if defined $onetimedumpDepth;
            dumpit( $OUT, \@res );
        }
        elsif ( $onetimeDump eq 'methods' ) {
            methods( $res[0] );
        }
    } ## end elsif ($onetimeDump)
    @res;
} ## end sub eval

############################################## End lexical danger zone

# After this point it is safe to introduce lexicals.
# The code being debugged will be executing in its own context, and
# can't see the inside of the debugger.
#
# However, one should not overdo it: leave as much control from outside as
# possible. If you make something a lexical, it's not going to be addressable
# from outside the debugger even if you know its name.

# This file is automatically included if you do perl -d.
# It's probably not useful to include this yourself.
#
# Before venturing further into these twisty passages, it is
# wise to read the perldebguts man page or risk the ire of dragons.
#
# (It should be noted that perldebguts will tell you a lot about
# the underlying mechanics of how the debugger interfaces into the
# Perl interpreter, but not a lot about the debugger itself. The new
# comments in this code try to address this problem.)

# Note that no subroutine call is possible until &DB::sub is defined
# (for subroutines defined outside of the package DB). In fact the same is
# true if $deep is not defined.

# Enhanced by ilya@math.ohio-state.edu (Ilya Zakharevich)

# modified Perl debugger, to be run from Emacs in perldb-mode
# Ray Lischner (uunet!mntgfx!lisch) as of 5 Nov 1990
# Johan Vromans -- upgrade to 4.0 pl 10
# Ilya Zakharevich -- patches after 5.001 (and some before ;-)
########################################################################

=head1 DEBUGGER INITIALIZATION

The debugger starts up in phases.

=head2 BASIC SETUP

First, it initializes the environment it wants to run in: turning off
warnings during its own compilation, defining variables which it will need
to avoid warnings later, setting itself up to not exit when the program
terminates, and defaulting to printing return values for the C<r> command.

=cut

# Needed for the statement after exec():
#
# This BEGIN block is simply used to switch off warnings during debugger
# compilation. Probably it would be better practice to fix the warnings,
# but this is how it's done at the moment.

BEGIN {
    $ini_warn = $^W;
    $^W       = 0;
}    # Switch compilation warnings off until another BEGIN.

local ($^W) = 0;    # Switch run-time warnings off during init.

=head2 THREADS SUPPORT

If we are running under a threaded Perl, we require threads and threads::shared
if the environment variable C<PERL5DB_THREADED> is set, to enable proper
threaded debugger control.  C<-dt> can also be used to set this.

Each new thread will be announced and the debugger prompt will always inform
you of each new thread created.  It will also indicate the thread id in which
we are currently running within the prompt like this:

    [tid] DB<$i>

Where C<[tid]> is an integer thread id and C<$i> is the familiar debugger
command prompt.  The prompt will show: C<[0]> when running under threads, but
not actually in a thread.  C<[tid]> is consistent with C<gdb> usage.

While running under threads, when you set or delete a breakpoint (etc.), this
will apply to all threads, not just the currently running one.  When you are
in a currently executing thread, you will stay there until it completes.  With
the current implementation it is not currently possible to hop from one thread
to another.

The C<e> and C<E> commands are currently fairly minimal - see
S<C<h e>> and S<C<h E>>.

Note that threading support was built into the debugger as of Perl version
C<5.8.6> and debugger version C<1.2.8>.

=cut

BEGIN {
    # ensure we can share our non-threaded variables or no-op
    if ($ENV{PERL5DB_THREADED}) {
        require threads;
        require threads::shared;
        import threads::shared qw(share);
        $DBGR;
        share(\$DBGR);
        lock($DBGR);
        print "Threads support enabled\n";
    } else {
        *lock = sub :prototype(*) {};
        *share = sub :prototype(\[$@%]) {};
    }
}

# These variables control the execution of 'dumpvar.pl'.
{
    package dumpvar;
    use vars qw(
    $hashDepth
    $arrayDepth
    $dumpDBFiles
    $dumpPackages
    $quoteHighBit
    $printUndef
    $globPrint
    $usageOnly
    );
}

# used to control die() reporting in diesignal()
{
    package Carp;
    use vars qw($CarpLevel);
}

# without threads, $filename is not defined until DB::DB is called
share($main::{'_<'.$filename}) if defined $filename;

# Command-line + PERLLIB:
# Save the contents of @INC before they are modified elsewhere.
@ini_INC = @INC;

# This was an attempt to clear out the previous values of various
# trapped errors. Apparently it didn't help. XXX More info needed!
# $prevwarn = $prevdie = $prevbus = $prevsegv = ''; # Does not help?!

# We set these variables to safe values. We don't want to blindly turn
# off warnings, because other packages may still want them.
$trace = $signal = $single = 0;    # Uninitialized warning suppression
                                   # (local $^W cannot help - other packages!).

# Default to not exiting when program finishes; print the return
# value when the 'r' command is used to return from a subroutine.
$inhibit_exit = $option{PrintRet} = 1;

use vars qw($trace_to_depth);

# Default to 1E9 so it won't be limited to a certain recursion depth.
$trace_to_depth = 1E9;

=head1 OPTION PROCESSING

The debugger's options are actually spread out over the debugger itself and
C<dumpvar.pl>; some of these are variables to be set, while others are
subs to be called with a value. To try to make this a little easier to
manage, the debugger uses a few data structures to define what options
are legal and how they are to be processed.

First, the C<@options> array defines the I<names> of all the options that
are to be accepted.

=cut

@options = qw(
  CommandSet   HistFile      HistSize
  HistItemMinLength
  hashDepth    arrayDepth    dumpDepth
  DumpDBFiles  DumpPackages  DumpReused
  compactDump  veryCompact   quote
  HighBit      undefPrint    globPrint
  PrintRet     UsageOnly     frame
  AutoTrace    TTY           noTTY
  ReadLine     NonStop       LineInfo
  maxTraceLen  recallCommand ShellBang
  pager        tkRunning     ornaments
  signalLevel  warnLevel     dieLevel
  inhibit_exit ImmediateStop bareStringify
  CreateTTY    RemotePort    windowSize
  DollarCaretP
);

@RememberOnROptions = qw(DollarCaretP);

=pod

Second, C<optionVars> lists the variables that each option uses to save its
state.

=cut

use vars qw(%optionVars);

%optionVars = (
    hashDepth     => \$dumpvar::hashDepth,
    arrayDepth    => \$dumpvar::arrayDepth,
    CommandSet    => \$CommandSet,
    DumpDBFiles   => \$dumpvar::dumpDBFiles,
    DumpPackages  => \$dumpvar::dumpPackages,
    DumpReused    => \$dumpvar::dumpReused,
    HighBit       => \$dumpvar::quoteHighBit,
    undefPrint    => \$dumpvar::printUndef,
    globPrint     => \$dumpvar::globPrint,
    UsageOnly     => \$dumpvar::usageOnly,
    CreateTTY     => \$CreateTTY,
    bareStringify => \$dumpvar::bareStringify,
    frame         => \$frame,
    AutoTrace     => \$trace,
    inhibit_exit  => \$inhibit_exit,
    maxTraceLen   => \$maxtrace,
    ImmediateStop => \$ImmediateStop,
    RemotePort    => \$remoteport,
    windowSize    => \$window,
    HistFile      => \$histfile,
    HistSize      => \$histsize,
    HistItemMinLength => \$histitemminlength
);

=pod

Third, C<%optionAction> defines the subroutine to be called to process each
option.

=cut

use vars qw(%optionAction);

%optionAction = (
    compactDump   => \&dumpvar::compactDump,
    veryCompact   => \&dumpvar::veryCompact,
    quote         => \&dumpvar::quote,
    TTY           => \&TTY,
    noTTY         => \&noTTY,
    ReadLine      => \&ReadLine,
    NonStop       => \&NonStop,
    LineInfo      => \&LineInfo,
    recallCommand => \&recallCommand,
    ShellBang     => \&shellBang,
    pager         => \&pager,
    signalLevel   => \&signalLevel,
    warnLevel     => \&warnLevel,
    dieLevel      => \&dieLevel,
    tkRunning     => \&tkRunning,
    ornaments     => \&ornaments,
    RemotePort    => \&RemotePort,
    DollarCaretP  => \&DollarCaretP,
);

=pod

Last, the C<%optionRequire> notes modules that must be C<require>d if an
option is used.

=cut

# Note that this list is not complete: several options not listed here
# actually require that dumpvar.pl be loaded for them to work, but are
# not in the table. A subsequent patch will correct this problem; for
# the moment, we're just recommenting, and we are NOT going to change
# function.
use vars qw(%optionRequire);

%optionRequire = (
    compactDump => 'dumpvar.pl',
    veryCompact => 'dumpvar.pl',
    quote       => 'dumpvar.pl',
);

=pod

There are a number of initialization-related variables which can be set
by putting code to set them in a BEGIN block in the C<PERL5DB> environment
variable. These are:

=over 4

=item C<$rl> - readline control XXX needs more explanation

=item C<$warnLevel> - whether or not debugger takes over warning handling

=item C<$dieLevel> - whether or not debugger takes over die handling

=item C<$signalLevel> - whether or not debugger takes over signal handling

=item C<$pre> - preprompt actions (array reference)

=item C<$post> - postprompt actions (array reference)

=item C<$pretype>

=item C<$CreateTTY> - whether or not to create a new TTY for this debugger

=item C<$CommandSet> - which command set to use (defaults to new, documented set)

=back

=cut

# These guys may be defined in $ENV{PERL5DB} :
$rl          = 1     unless defined $rl;
$warnLevel   = 1     unless defined $warnLevel;
$dieLevel    = 1     unless defined $dieLevel;
$signalLevel = 1     unless defined $signalLevel;
$pre         = []    unless defined $pre;
$post        = []    unless defined $post;
$pretype     = []    unless defined $pretype;
$CreateTTY   = 3     unless defined $CreateTTY;
$CommandSet  = '580' unless defined $CommandSet;

share($rl);
share($warnLevel);
share($dieLevel);
share($signalLevel);
share($pre);
share($post);
share($pretype);
share($CreateTTY);
share($CommandSet);

=pod

The default C<die>, C<warn>, and C<signal> handlers are set up.

=cut

warnLevel($warnLevel);
dieLevel($dieLevel);
signalLevel($signalLevel);

=pod

The pager to be used is needed next. We try to get it from the
environment first.  If it's not defined there, we try to find it in
the Perl C<Config.pm>.  If it's not there, we default to C<more>. We
then call the C<pager()> function to save the pager name.

=cut

# This routine makes sure $pager is set up so that '|' can use it.
pager(

    # If PAGER is defined in the environment, use it.
    defined $ENV{PAGER}
    ? $ENV{PAGER}

      # If not, see if Config.pm defines it.
    : eval { require Config }
      && defined $Config::Config{pager}
    ? $Config::Config{pager}

      # If not, fall back to 'more'.
    : 'more'
  )
  unless defined $pager;

=pod

We set up the command to be used to access the man pages, the command
recall character (C<!> unless otherwise defined) and the shell escape
character (C<!> unless otherwise defined). Yes, these do conflict, and
neither works in the debugger at the moment.

=cut

setman();

# Set up defaults for command recall and shell escape (note:
# these currently don't work in linemode debugging).
recallCommand("!") unless defined $prc;
shellBang("!")     unless defined $psh;

=pod

We then set up the gigantic string containing the debugger help.
We also set the limit on the number of arguments we'll display during a
trace.

=cut

sethelp();

# If we didn't get a default for the length of eval/stack trace args,
# set it here.
$maxtrace = 400 unless defined $maxtrace;

=head2 SETTING UP THE DEBUGGER GREETING

The debugger I<greeting> helps to inform the user how many debuggers are
running, and whether the current debugger is the primary or a child.

If we are the primary, we just hang onto our pid so we'll have it when
or if we start a child debugger. If we are a child, we'll set things up
so we'll have a unique greeting and so the parent will give us our own
TTY later.

We save the current contents of the C<PERLDB_PIDS> environment variable
because we mess around with it. We'll also need to hang onto it because
we'll need it if we restart.

Child debuggers make a label out of the current PID structure recorded in
PERLDB_PIDS plus the new PID. They also mark themselves as not having a TTY
yet so the parent will give them one later via C<resetterm()>.

=cut

# Save the current contents of the environment; we're about to
# much with it. We'll need this if we have to restart.
use vars qw($ini_pids);
$ini_pids = $ENV{PERLDB_PIDS};

use vars qw ($pids $term_pid);

if ( defined $ENV{PERLDB_PIDS} ) {

    # We're a child. Make us a label out of the current PID structure
    # recorded in PERLDB_PIDS plus our (new) PID. Mark us as not having
    # a term yet so the parent will give us one later via resetterm().

    my $env_pids = $ENV{PERLDB_PIDS};
    $pids = "[$env_pids]";

    # Unless we are on OpenVMS, all programs under the DCL shell run under
    # the same PID.

    if (($^O eq 'VMS') && ($env_pids =~ /\b$$\b/)) {
        $term_pid         = $$;
    }
    else {
        $ENV{PERLDB_PIDS} .= "->$$";
        $term_pid = -1;
    }

} ## end if (defined $ENV{PERLDB_PIDS...
else {

    # We're the parent PID. Initialize PERLDB_PID in case we end up with a
    # child debugger, and mark us as the parent, so we'll know to set up
    # more TTY's is we have to.
    $ENV{PERLDB_PIDS} = "$$";
    $pids             = "[pid=$$]";
    $term_pid         = $$;
}

use vars qw($pidprompt);
$pidprompt = '';

# Sets up $emacs as a synonym for $client_editor.
our ($client_editor);
*emacs = $client_editor if $client_editor;    # May be used in afterinit()...

=head2 READING THE RC FILE

The debugger will read a file of initialization options if supplied. If
running interactively, this is C<.perldb>; if not, it's C<perldb.ini>.

=cut

# As noted, this test really doesn't check accurately that the debugger
# is running at a terminal or not.

use vars qw($rcfile);
{
    my $dev_tty = (($^O eq 'VMS') ? 'TT:' : '/dev/tty');
    # this is the wrong metric!
    $rcfile = ((-e $dev_tty) ? ".perldb" : "perldb.ini");
}

=pod

The debugger does a safety test of the file to be read. It must be owned
either by the current user or root, and must only be writable by the owner.

=cut

# This wraps a safety test around "do" to read and evaluate the init file.
#
# This isn't really safe, because there's a race
# between checking and opening.  The solution is to
# open and fstat the handle, but then you have to read and
# eval the contents.  But then the silly thing gets
# your lexical scope, which is unfortunate at best.
sub safe_do {
    my $file = shift;

    # Just exactly what part of the word "CORE::" don't you understand?
    local $SIG{__WARN__};
    local $SIG{__DIE__};

    unless ( is_safe_file($file) ) {
        CORE::warn <<EO_GRIPE;
perldb: Must not source insecure rcfile $file.
        You or the superuser must be the owner, and it must not
        be writable by anyone but its owner.
EO_GRIPE
        return;
    } ## end unless (is_safe_file($file...

    do $file;
    CORE::warn("perldb: couldn't parse $file: $@") if $@;
} ## end sub safe_do

# This is the safety test itself.
#
# Verifies that owner is either real user or superuser and that no
# one but owner may write to it.  This function is of limited use
# when called on a path instead of upon a handle, because there are
# no guarantees that filename (by dirent) whose file (by ino) is
# eventually accessed is the same as the one tested.
# Assumes that the file's existence is not in doubt.
sub is_safe_file {
    my $path = shift;
    stat($path) || return;    # mysteriously vaporized
    my ( $dev, $ino, $mode, $nlink, $uid, $gid ) = stat(_);

    return 0 if $uid != 0 && $uid != $<;
    return 0 if $mode & 022;
    return 1;
} ## end sub is_safe_file

# If the rcfile (whichever one we decided was the right one to read)
# exists, we safely do it.
if ( -f $rcfile ) {
    safe_do("./$rcfile");
}

# If there isn't one here, try the user's home directory.
elsif ( defined $ENV{HOME} && -f "$ENV{HOME}/$rcfile" ) {
    safe_do("$ENV{HOME}/$rcfile");
}

# Else try the login directory.
elsif ( defined $ENV{LOGDIR} && -f "$ENV{LOGDIR}/$rcfile" ) {
    safe_do("$ENV{LOGDIR}/$rcfile");
}

# If the PERLDB_OPTS variable has options in it, parse those out next.
if ( defined $ENV{PERLDB_OPTS} ) {
    parse_options( $ENV{PERLDB_OPTS} );
}

=pod

The last thing we do during initialization is determine which subroutine is
to be used to obtain a new terminal when a new debugger is started. Right now,
the debugger only handles TCP sockets, X11, OS/2, amd Mac OS X
(darwin).

=cut

# Set up the get_fork_TTY subroutine to be aliased to the proper routine.
# Works if you're running an xterm or xterm-like window, or you're on
# OS/2, or on Mac OS X. This may need some expansion.

if (not defined &get_fork_TTY)       # only if no routine exists
{
    if ( defined $remoteport ) {
                                                 # Expect an inetd-like server
        *get_fork_TTY = \&socket_get_fork_TTY;   # to listen to us
    }
    elsif (defined $ENV{TERM}                    # If we know what kind
                                                 # of terminal this is,
        and $ENV{TERM} eq 'xterm'                # and it's an xterm,
        and defined $ENV{DISPLAY}                # and what display it's on,
      )
    {
        *get_fork_TTY = \&xterm_get_fork_TTY;    # use the xterm version
    }
    elsif ( $ENV{TMUX} ) {
        *get_fork_TTY = \&tmux_get_fork_TTY;
    }
    elsif ( $^O eq 'os2' ) {                     # If this is OS/2,
        *get_fork_TTY = \&os2_get_fork_TTY;      # use the OS/2 version
    }
    elsif ( $^O eq 'darwin'                      # If this is Mac OS X
            and defined $ENV{TERM_PROGRAM}       # and we're running inside
            and $ENV{TERM_PROGRAM}
                eq 'Apple_Terminal'              # Terminal.app
            )
    {
        *get_fork_TTY = \&macosx_get_fork_TTY;   # use the Mac OS X version
    }
} ## end if (not defined &get_fork_TTY...

# untaint $^O, which may have been tainted by the last statement.
# see bug [perl #24674]
$^O =~ m/^(.*)\z/;
$^O = $1;

# Here begin the unreadable code.  It needs fixing.

=head2 RESTART PROCESSING

This section handles the restart command. When the C<R> command is invoked, it
tries to capture all of the state it can into environment variables, and
then sets C<PERLDB_RESTART>. When we start executing again, we check to see
if C<PERLDB_RESTART> is there; if so, we reload all the information that
the R command stuffed into the environment variables.

  PERLDB_RESTART   - flag only, contains no restart data itself.
  PERLDB_HIST      - command history, if it's available
  PERLDB_ON_LOAD   - breakpoints set by the rc file
  PERLDB_POSTPONE  - subs that have been loaded/not executed,
                     and have actions
  PERLDB_VISITED   - files that had breakpoints
  PERLDB_FILE_...  - breakpoints for a file
  PERLDB_OPT       - active options
  PERLDB_INC       - the original @INC
  PERLDB_PRETYPE   - preprompt debugger actions
  PERLDB_PRE       - preprompt Perl code
  PERLDB_POST      - post-prompt Perl code
  PERLDB_TYPEAHEAD - typeahead captured by readline()

We chug through all these variables and plug the values saved in them
back into the appropriate spots in the debugger.

=cut

use vars qw(%postponed_file @typeahead);

our (@hist, @truehist);

sub _restore_shared_globals_after_restart
{
    @hist          = get_list('PERLDB_HIST');
    %break_on_load = get_list("PERLDB_ON_LOAD");
    %postponed     = get_list("PERLDB_POSTPONE");

    share(@hist);
    share(@truehist);
    share(%break_on_load);
    share(%postponed);
}

sub _restore_breakpoints_and_actions {

    my @had_breakpoints = get_list("PERLDB_VISITED");

    for my $file_idx ( 0 .. $#had_breakpoints ) {
        my $filename = $had_breakpoints[$file_idx];
        my %pf = get_list("PERLDB_FILE_$file_idx");
        $postponed_file{ $filename } = \%pf if %pf;
        my @lines = sort {$a <=> $b} keys(%pf);
        my @enabled_statuses = get_list("PERLDB_FILE_ENABLED_$file_idx");
        for my $line_idx (0 .. $#lines) {
            _set_breakpoint_enabled_status(
                $filename,
                $lines[$line_idx],
                ($enabled_statuses[$line_idx] ? 1 : ''),
            );
        }
    }

    return;
}

sub _restore_options_after_restart
{
    my %options_map = get_list("PERLDB_OPT");

    while ( my ( $opt, $val ) = each %options_map ) {
        $val =~ s/[\\\']/\\$1/g;
        parse_options("$opt'$val'");
    }

    return;
}

sub _restore_globals_after_restart
{
    # restore original @INC
    @INC     = get_list("PERLDB_INC");
    @ini_INC = @INC;

    # return pre/postprompt actions and typeahead buffer
    $pretype   = [ get_list("PERLDB_PRETYPE") ];
    $pre       = [ get_list("PERLDB_PRE") ];
    $post      = [ get_list("PERLDB_POST") ];
    @typeahead = get_list( "PERLDB_TYPEAHEAD", @typeahead );

    return;
}


if ( exists $ENV{PERLDB_RESTART} ) {

    # We're restarting, so we don't need the flag that says to restart anymore.
    delete $ENV{PERLDB_RESTART};

    # $restart = 1;
    _restore_shared_globals_after_restart();

    _restore_breakpoints_and_actions();

    # restore options
    _restore_options_after_restart();

    _restore_globals_after_restart();
} ## end if (exists $ENV{PERLDB_RESTART...

=head2 SETTING UP THE TERMINAL

Now, we'll decide how the debugger is going to interact with the user.
If there's no TTY, we set the debugger to run non-stop; there's not going
to be anyone there to enter commands.

=cut

use vars qw($notty $console $tty $LINEINFO);
use vars qw($lineinfo $doccmd);

our ($runnonstop);

# Local autoflush to avoid rt#116769,
# as calling IO::File methods causes an unresolvable loop
# that results in debugger failure.
sub _autoflush {
    my $o = select($_[0]);
    $|++;
    select($o);
}

if ($notty) {
    $runnonstop = 1;
    share($runnonstop);
}

=pod

If there is a TTY, we have to determine who it belongs to before we can
proceed. If this is a client editor or graphical debugger (denoted by
the first command-line switch being '-emacs'), we shift this off and
set C<$rl> to 0 (XXX ostensibly to do straight reads).

=cut

else {

    # Is Perl being run from a client editor or graphical debugger?
    # If so, don't use readline, and set $client_editor = 1.
    if ($client_editor = ( @main::ARGV && ( $main::ARGV[0] eq '-emacs' ) )) {
        $rl = 0;
        shift(@main::ARGV);
    }

    #require Term::ReadLine;

=pod

We then determine what the console should be on various systems:

=over 4

=item * Cygwin - We use C<stdin> instead of a separate device.

=cut

    if ( $^O eq 'cygwin' ) {

        # /dev/tty is binary. use stdin for textmode
        undef $console;
    }

=item * Windows - use C<con>.

=cut

    elsif ( $^O eq 'MSWin32' and -e "con" ) {
        $console = "con";
    }

=item * AmigaOS - use C<CONSOLE:>.

=cut

    elsif ( $^O eq 'amigaos' ) {
        $console = "CONSOLE:";
    }

=item * VMS - use C<sys$command>.

=cut

    elsif ($^O eq 'VMS') {
        $console = 'sys$command';
    }

# Keep this penultimate, on the grounds that it satisfies a wide variety of
# Unix-like systems that would otherwise need to be identified individually.

=item * Unix - use F</dev/tty>.

=cut

    elsif ( -e "/dev/tty" ) {
        $console = "/dev/tty";
    }

# Keep this last.

    else {
        _db_warn("Can't figure out your console, using stdin");
        undef $console;
    }

=pod

=back

Several other systems don't use a specific console. We S<C<undef $console>>
for those (Windows using a client editor/graphical debugger, OS/2
with a client editor).

=cut

    if ( ( $^O eq 'MSWin32' ) and ( $client_editor or defined $ENV{EMACS} ) ) {

        # /dev/tty is binary. use stdin for textmode
        $console = undef;
    }

    # In OS/2, we need to use STDIN to get textmode too, even though
    # it pretty much looks like Unix otherwise.
    if ( defined $ENV{OS2_SHELL} and ( $client_editor or $ENV{WINDOWID} ) )
    {    # In OS/2
        $console = undef;
    }

=pod

If there is a TTY hanging around from a parent, we use that as the console.

=cut

    $console = $tty if defined $tty;

=head2 SOCKET HANDLING

The debugger is capable of opening a socket and carrying out a debugging
session over the socket.

If C<RemotePort> was defined in the options, the debugger assumes that it
should try to start a debugging session on that port. It builds the socket
and then tries to connect the input and output filehandles to it.

=cut

    # Handle socket stuff.

    if ( defined $remoteport ) {

        # If RemotePort was defined in the options, connect input and output
        # to the socket.
        $IN = $OUT = connect_remoteport();
    } ## end if (defined $remoteport)

=pod

If no C<RemotePort> was defined, and we want to create a TTY on startup,
this is probably a situation where multiple debuggers are running (for example,
a backticked command that starts up another debugger). We create a new IN and
OUT filehandle, and do the necessary mojo to create a new TTY if we know how
and if we can.

=cut

    # Non-socket.
    else {

        # Two debuggers running (probably a system or a backtick that invokes
        # the debugger itself under the running one). create a new IN and OUT
        # filehandle, and do the necessary mojo to create a new tty if we
        # know how, and we can.
        create_IN_OUT(4) if $CreateTTY & 4;
        if ($console) {

            # If we have a console, check to see if there are separate ins and
            # outs to open. (They are assumed identical if not.)

            my ( $i, $o ) = split /,/, $console;
            $o = $i unless defined $o;

            # read/write on in, or just read, or read on STDIN.
                 open( IN, '+<', $i )
              || open( IN, '<',  $i )
              || open( IN, "<&STDIN" );

            # read/write/create/clobber out, or write/create/clobber out,
            # or merge with STDERR, or merge with STDOUT.
                 open( OUT, '+>', $o )
              || open( OUT, '>',  $o )
              || open( OUT, ">&STDERR" )
              || open( OUT, ">&STDOUT" );    # so we don't dongle stdout

        } ## end if ($console)
        elsif ( not defined $console ) {

            # No console. Open STDIN.
            open( IN, "<&STDIN" );

            # merge with STDERR, or with STDOUT.
            open( OUT,      ">&STDERR" )
              || open( OUT, ">&STDOUT" );    # so we don't dongle stdout
            $console = 'STDIN/OUT';
        } ## end elsif (not defined $console)

        # Keep copies of the filehandles so that when the pager runs, it
        # can close standard input without clobbering ours.
        if ($console or (not defined($console))) {
            $IN = \*IN;
            $OUT = \*OUT;
        }
    } ## end elsif (from if(defined $remoteport))

    # Unbuffer DB::OUT. We need to see responses right away.
    _autoflush($OUT);

    # Line info goes to debugger output unless pointed elsewhere.
    # Pointing elsewhere makes it possible for client editors to
    # keep track of file and position. We have both a filehandle
    # and a I/O description to keep track of.
    $LINEINFO = $OUT     unless defined $LINEINFO;
    $lineinfo = $console unless defined $lineinfo;
    # share($LINEINFO); # <- unable to share globs
    share($lineinfo);   #

=pod

To finish initialization, we show the debugger greeting,
and then call the C<afterinit()> subroutine if there is one.

=cut

    # Show the debugger greeting.
    $header =~ s/.Header: ([^,]+),v(\s+\S+\s+\S+).*$/$1$2/;
    unless ($runnonstop) {
        local $\ = '';
        local $, = '';
        if ( $term_pid eq '-1' ) {
            print $OUT "\nDaughter DB session started...\n";
        }
        else {
            print $OUT "\nLoading DB routines from $header\n";
            print $OUT (
                "Editor support ",
                $client_editor ? "enabled" : "available", ".\n"
            );
            print $OUT
"\nEnter h or 'h h' for help, or '$doccmd perldebug' for more help.\n\n";
        } ## end else [ if ($term_pid eq '-1')
    } ## end unless ($runnonstop)
} ## end else [ if ($notty)

# XXX This looks like a bug to me.
# Why copy to @ARGS and then futz with @args?
@ARGS = @ARGV;
# for (@args) {
    # Make sure backslashes before single quotes are stripped out, and
    # keep args unless they are numeric (XXX why?)
    # s/\'/\\\'/g;                      # removed while not justified understandably
    # s/(.*)/'$1'/ unless /^-?[\d.]+$/; # ditto
# }

# If there was an afterinit() sub defined, call it. It will get
# executed in our scope, so it can fiddle with debugger globals.
if ( defined &afterinit ) {    # May be defined in $rcfile
    afterinit();
}

# Inform us about "Stack dump during die enabled ..." in dieLevel().
use vars qw($I_m_init);

$I_m_init = 1;

############################################################ Subroutines

=head1 SUBROUTINES

=head2 DB

This gigantic subroutine is the heart of the debugger. Called before every
statement, its job is to determine if a breakpoint has been reached, and
stop if so; read commands from the user, parse them, and execute
them, and then send execution off to the next statement.

Note that the order in which the commands are processed is very important;
some commands earlier in the loop will actually alter the C<$cmd> variable
to create other commands to be executed later. This is all highly I<optimized>
but can be confusing. Check the comments for each C<$cmd ... && do {}> to
see what's happening in any given command.

=cut

# $cmd cannot be an our() variable unfortunately (possible perl bug?).

use vars qw(
    $action
    $cmd
    $file
    $filename_ini
    $finished
    %had_breakpoints
    $level
    $max
    $package
    $try
);

our (
    %alias,
    $doret,
    $end,
    $fall_off_end,
    $incr,
    $laststep,
    $rc,
    $sh,
    $stack_depth,
    @stack,
    @to_watch,
    @old_watch,
);

sub _DB__determine_if_we_should_break
{
    # if we have something here, see if we should break.
    # $stop is lexical and local to this block - $action on the other hand
    # is global.
    my $stop;

    if ( $dbline{$line}
        && _is_breakpoint_enabled($filename, $line)
        && (( $stop, $action ) = split( /\0/, $dbline{$line} ) ) )
    {

        # Stop if the stop criterion says to just stop.
        if ( $stop eq '1' ) {
            $signal |= 1;
        }

        # It's a conditional stop; eval it in the user's context and
        # see if we should stop. If so, remove the one-time sigil.
        elsif ($stop) {
            $evalarg = "\$DB::signal |= 1 if do {$stop}";
            # The &-call is here to ascertain the mutability of @_.
            &DB::eval;
            # If the breakpoint is temporary, then delete its enabled status.
            if ($dbline{$line} =~ s/;9($|\0)/$1/) {
                _cancel_breakpoint_temp_enabled_status($filename, $line);
            }
        }
    } ## end if ($dbline{$line} && ...
}

sub _DB__is_finished {
    if ($finished and $level <= 1) {
        end_report();
        return 1;
    }
    else {
        return;
    }
}

sub _DB__read_next_cmd
{
    my ($tid) = @_;

    # We have a terminal, or can get one ...
    if (!$term) {
        setterm();
    }

    # ... and it belongs to this PID or we get one for this PID ...
    if ($term_pid != $$) {
        resetterm(1);
    }

    # ... and we got a line of command input ...
    $cmd = DB::readline(
        "$pidprompt $tid DB"
        . ( '<' x $level )
        . ( $#hist + 1 )
        . ( '>' x $level ) . " "
    );

    return defined($cmd);
}

sub _DB__trim_command_and_return_first_component {
    my ($obj) = @_;

    $cmd =~ s/\A\s+//s;    # trim annoying leading whitespace
    $cmd =~ s/\s+\z//s;    # trim annoying trailing whitespace

    # A single-character debugger command can be immediately followed by its
    # argument if they aren't both alphanumeric; otherwise require space
    # between commands and arguments:
    my ($verb, $args) = $cmd =~ m{\A([^\.-]\b|\S*)\s*(.*)}s;

    $obj->cmd_verb($verb);
    $obj->cmd_args($args);

    return;
}

sub _DB__handle_f_command {
    my ($obj) = @_;

    if ($file = $obj->cmd_args) {
        # help for no arguments (old-style was return from sub).
        if ( !$file ) {
            print $OUT
            "The old f command is now the r command.\n";    # hint
            print $OUT "The new f command switches filenames.\n";
            next CMD;
        } ## end if (!$file)

        # if not in magic file list, try a close match.
        if ( !defined $main::{ '_<' . $file } ) {
            if ( ($try) = grep( m#^_<.*$file#, keys %main:: ) ) {
                {
                    $try = substr( $try, 2 );
                    print $OUT "Choosing $try matching '$file':\n";
                    $file = $try;
                }
            } ## end if (($try) = grep(m#^_<.*$file#...
        } ## end if (!defined $main::{ ...

        # If not successfully switched now, we failed.
        if ( !defined $main::{ '_<' . $file } ) {
            print $OUT "No file matching '$file' is loaded.\n";
            next CMD;
        }

        # We switched, so switch the debugger internals around.
        elsif ( $file ne $filename ) {
            *dbline   = $main::{ '_<' . $file };
            $max      = $#dbline;
            $filename = $file;
            $start    = 1;
            $cmd      = "l";
        } ## end elsif ($file ne $filename)

        # We didn't switch; say we didn't.
        else {
            print $OUT "Already in $file.\n";
            next CMD;
        }
    }

    return;
}

sub _DB__handle_dot_command {
    my ($obj) = @_;

    # . command.
    if ($obj->_is_full('.')) {
        $incr = -1;    # stay at current line

        # Reset everything to the old location.
        $start    = $line;
        $filename = $filename_ini;
        *dbline   = $main::{ '_<' . $filename };
        $max      = $#dbline;

        # Now where are we?
        print_lineinfo($obj->position());
        next CMD;
    }

    return;
}

sub _DB__handle_y_command {
    my ($obj) = @_;

    if (my ($match_level, $match_vars)
        = $obj->cmd_args =~ /\A(?:(\d*)\s*(.*))?\z/) {

        # See if we've got the necessary support.
        if (!eval {
            local @INC = @INC;
            pop @INC if $INC[-1] eq '.';
            require PadWalker; PadWalker->VERSION(0.08) }) {
            my $Err = $@;
            _db_warn(
                $Err =~ /locate/
                ? "PadWalker module not found - please install\n"
                : $Err
            );
            next CMD;
        }

        # Load up dumpvar if we don't have it. If we can, that is.
        do 'dumpvar.pl' || die $@ unless defined &main::dumpvar;
        defined &main::dumpvar
            or print $OUT "dumpvar.pl not available.\n"
            and next CMD;

        # Got all the modules we need. Find them and print them.
        my @vars = split( ' ', $match_vars || '' );

        # Find the pad.
        my $h = eval { PadWalker::peek_my( ( $match_level || 0 ) + 2 ) };

        # Oops. Can't find it.
        if (my $Err = $@) {
            $Err =~ s/ at .*//;
            _db_warn($Err);
            next CMD;
        }

        # Show the desired vars with dumplex().
        my $savout = select($OUT);

        # Have dumplex dump the lexicals.
        foreach my $key (sort keys %$h) {
            dumpvar::dumplex( $key, $h->{$key},
                defined $option{dumpDepth} ? $option{dumpDepth} : -1,
                @vars );
        }
        select($savout);
        next CMD;
    }
}

sub _DB__handle_c_command {
    my ($obj) = @_;

    my $i = $obj->cmd_args;

    if ($i =~ m#\A[\w:]*\z#) {

        # Hey, show's over. The debugged program finished
        # executing already.
        next CMD if _DB__is_finished();

        # Capture the place to put a one-time break.
        $subname = $i;

        #  Probably not needed, since we finish an interactive
        #  sub-session anyway...
        # local $filename = $filename;
        # local *dbline = *dbline; # XXX Would this work?!
        #
        # The above question wonders if localizing the alias
        # to the magic array works or not. Since it's commented
        # out, we'll just leave that to speculation for now.

        # If the "subname" isn't all digits, we'll assume it
        # is a subroutine name, and try to find it.
        if ( $subname =~ /\D/ ) {    # subroutine name
            # Qualify it to the current package unless it's
            # already qualified.
            $subname = $package . "::" . $subname
            unless $subname =~ /::/;

            # find_sub will return "file:line_number" corresponding
            # to where the subroutine is defined; we call find_sub,
            # break up the return value, and assign it in one
            # operation.
            ( $file, $i ) = ( find_sub($subname) =~ /^(.*):(.*)$/ );

            # Force the line number to be numeric.
            $i = $i + 0;

            # If we got a line number, we found the sub.
            if ($i) {

                # Switch all the debugger's internals around so
                # we're actually working with that file.
                $filename = $file;
                *dbline   = $main::{ '_<' . $filename };

                # Mark that there's a breakpoint in this file.
                $had_breakpoints{$filename} |= 1;

                # Scan forward to the first executable line
                # after the 'sub whatever' line.
                $max = $#dbline;
                my $_line_num = $i;
                while ($dbline[$_line_num] == 0 && $_line_num< $max)
                {
                    $_line_num++;
                }
                $i = $_line_num;
            } ## end if ($i)

            # We didn't find a sub by that name.
            else {
                print $OUT "Subroutine $subname not found.\n";
                next CMD;
            }
        } ## end if ($subname =~ /\D/)

        # At this point, either the subname was all digits (an
        # absolute line-break request) or we've scanned through
        # the code following the definition of the sub, looking
        # for an executable, which we may or may not have found.
        #
        # If $i (which we set $subname from) is non-zero, we
        # got a request to break at some line somewhere. On
        # one hand, if there wasn't any real subroutine name
        # involved, this will be a request to break in the current
        # file at the specified line, so we have to check to make
        # sure that the line specified really is breakable.
        #
        # On the other hand, if there was a subname supplied, the
        # preceding block has moved us to the proper file and
        # location within that file, and then scanned forward
        # looking for the next executable line. We have to make
        # sure that one was found.
        #
        # On the gripping hand, we can't do anything unless the
        # current value of $i points to a valid breakable line.
        # Check that.
        if ($i) {

            # Breakable?
            if ( $dbline[$i] == 0 ) {
                print $OUT "Line $i not breakable.\n";
                next CMD;
            }

            # Yes. Set up the one-time-break sigil.
            $dbline{$i} =~ s/($|\0)/;9$1/;  # add one-time-only b.p.
            _enable_breakpoint_temp_enabled_status($filename, $i);
        } ## end if ($i)

        # Turn off stack tracing from here up.
        for my $j (0 .. $stack_depth) {
            $stack[ $j ] &= ~1;
        }
        last CMD;
    }

    return;
}

my $sub_twice = chr utf8::unicode_to_native(032);
$sub_twice = $sub_twice x 2;

sub _DB__handle_forward_slash_command {
    my ($obj) = @_;

    # The pattern as a string.
    use vars qw($inpat);

    if (($inpat) = $cmd =~ m#\A/(.*)\z#) {

        # Remove the final slash.
        $inpat =~ s:([^\\])/$:$1:;

        # If the pattern isn't null ...
        if ( $inpat ne "" ) {

            # Turn off warn and die processing for a bit.
            local $SIG{__DIE__};
            local $SIG{__WARN__};

            # Create the pattern.
            eval 'no strict q/vars/; $inpat =~ m' . "\a$inpat\a";
            if ( $@ ne "" ) {

                # Oops. Bad pattern. No biscuit.
                # Print the eval error and go back for more
                # commands.
                print {$OUT} "$@";
                next CMD;
            }
            $obj->pat($inpat);
        } ## end if ($inpat ne "")

        # Set up to stop on wrap-around.
        $end = $start;

        # Don't move off the current line.
        $incr = -1;

        my $pat = $obj->pat;

        # Done in eval so nothing breaks if the pattern
        # does something weird.
        eval
        {
            no strict q/vars/;
            for (;;) {
                # Move ahead one line.
                ++$start;

                # Wrap if we pass the last line.
                if ($start > $max) {
                    $start = 1;
                }

                # Stop if we have gotten back to this line again,
                last if ($start == $end);

                # A hit! (Note, though, that we are doing
                # case-insensitive matching. Maybe a qr//
                # expression would be better, so the user could
                # do case-sensitive matching if desired.
                if ($dbline[$start] =~ m/$pat/i) {
                    if ($client_editor) {
                        # Handle proper escaping in the client.
                        print {$OUT} "$sub_twice$filename:$start:0\n";
                    }
                    else {
                        # Just print the line normally.
                        print {$OUT} "$start:\t",$dbline[$start],"\n";
                    }
                    # And quit since we found something.
                    last;
                }
            }
        };

        if ($@) {
            warn $@;
        }

        # If we wrapped, there never was a match.
        if ( $start == $end ) {
            print {$OUT} "/$pat/: not found\n";
        }
        next CMD;
    }

    return;
}

sub _DB__handle_question_mark_command {
    my ($obj) = @_;

    # ? - backward pattern search.
    if (my ($inpat) = $cmd =~ m#\A\?(.*)\z#) {

        # Get the pattern, remove trailing question mark.
        $inpat =~ s:([^\\])\?$:$1:;

        # If we've got one ...
        if ( $inpat ne "" ) {

            # Turn off die & warn handlers.
            local $SIG{__DIE__};
            local $SIG{__WARN__};
            eval '$inpat =~ m' . "\a$inpat\a";

            if ( $@ ne "" ) {

                # Ouch. Not good. Print the error.
                print $OUT $@;
                next CMD;
            }
            $obj->pat($inpat);
        } ## end if ($inpat ne "")

        # Where we are now is where to stop after wraparound.
        $end = $start;

        # Don't move away from this line.
        $incr = -1;

        my $pat = $obj->pat;
        # Search inside the eval to prevent pattern badness
        # from killing us.
        eval {
            no strict q/vars/;
            for (;;) {
                # Back up a line.
                --$start;

                # Wrap if we pass the first line.

                $start = $max if ($start <= 0);

                # Quit if we get back where we started,
                last if ($start == $end);

                # Match?
                if ($dbline[$start] =~ m/$pat/i) {
                    if ($client_editor) {
                        # Yep, follow client editor requirements.
                        print $OUT "$sub_twice$filename:$start:0\n";
                    }
                    else {
                        # Yep, just print normally.
                        print $OUT "$start:\t",$dbline[$start],"\n";
                    }

                    # Found, so done.
                    last;
                }
            }
        };

        # Say we failed if the loop never found anything,
        if ( $start == $end ) {
            print {$OUT} "?$pat?: not found\n";
        }
        next CMD;
    }

    return;
}

sub _DB__handle_restart_and_rerun_commands {
    my ($obj) = @_;

    my $cmd_cmd = $obj->cmd_verb;
    my $cmd_params = $obj->cmd_args;
    # R - restart execution.
    # rerun - controlled restart execution.
    if ($cmd_cmd eq 'rerun' or $cmd_params eq '') {

        # Change directory to the initial current working directory on
        # the script startup, so if the debugged program changed the
        # directory, then we will still be able to find the path to the
        # program. (perl 5 RT #121509 ).
        chdir ($_initial_cwd);

        my @args = ($cmd_cmd eq 'R' ? restart() : rerun($cmd_params));

        # Close all non-system fds for a clean restart.  A more
        # correct method would be to close all fds that were not
        # open when the process started, but this seems to be
        # hard.  See "debugger 'R'estart and open database
        # connections" on p5p.

        my $max_fd = 1024; # default if POSIX can't be loaded
        if (eval { require POSIX }) {
            eval { $max_fd = POSIX::sysconf(POSIX::_SC_OPEN_MAX()) };
        }

        if (defined $max_fd) {
            foreach ($^F+1 .. $max_fd-1) {
                next unless open FD_TO_CLOSE, "<&=$_";
                close(FD_TO_CLOSE);
            }
        }

        # And run Perl again.  We use exec() to keep the
        # PID stable (and that way $ini_pids is still valid).
        exec(@args) or print {$OUT} "exec failed: $!\n";

        last CMD;
    }

    return;
}

sub _DB__handle_run_command_in_pager_command {
    my ($obj) = @_;

    if ($cmd =~ m#\A\|\|?\s*[^|]#) {
        if ( $pager =~ /^\|/ ) {

            # Default pager is into a pipe. Redirect I/O.
            open( SAVEOUT, ">&STDOUT" )
            || _db_warn("Can't save STDOUT");
            open( STDOUT, ">&OUT" )
            || _db_warn("Can't redirect STDOUT");
        } ## end if ($pager =~ /^\|/)
        else {

            # Not into a pipe. STDOUT is safe.
            open( SAVEOUT, ">&OUT" ) || _db_warn("Can't save DB::OUT");
        }

        # Fix up environment to record we have less if so.
        fix_less();

        unless ( $obj->piped(scalar ( open( OUT, $pager ) ) ) ) {

            # Couldn't open pipe to pager.
            _db_warn("Can't pipe output to '$pager'");
            if ( $pager =~ /^\|/ ) {

                # Redirect I/O back again.
                open( OUT, ">&STDOUT" )    # XXX: lost message
                || _db_warn("Can't restore DB::OUT");
                open( STDOUT, ">&SAVEOUT" )
                || _db_warn("Can't restore STDOUT");
                close(SAVEOUT);
            } ## end if ($pager =~ /^\|/)
            else {

                # Redirect I/O. STDOUT already safe.
                open( OUT, ">&STDOUT" )    # XXX: lost message
                || _db_warn("Can't restore DB::OUT");
            }
            next CMD;
        } ## end unless ($piped = open(OUT,...

        # Set up broken-pipe handler if necessary.
        $SIG{PIPE} = \&DB::catch
        if $pager =~ /^\|/
        && ( "" eq $SIG{PIPE} || "DEFAULT" eq $SIG{PIPE} );

        _autoflush(\*OUT);
        # Save current filehandle, and put it back.
        $obj->selected(scalar( select(OUT) ));
        # Don't put it back if pager was a pipe.
        if ($cmd !~ /\A\|\|/)
        {
            select($obj->selected());
            $obj->selected("");
        }

        # Trim off the pipe symbols and run the command now.
        $cmd =~ s#\A\|+\s*##;
        redo PIPE;
    }

    return;
}

sub _DB__handle_m_command {
    my ($obj) = @_;

    if ($cmd =~ s#\Am\s+([\w:]+)\s*\z# #) {
        methods($1);
        next CMD;
    }

    # m expr - set up DB::eval to do the work
    if ($cmd =~ s#\Am\b# #) {    # Rest gets done by DB::eval()
        $onetimeDump = 'methods';   #  method output gets used there
    }

    return;
}

sub _DB__at_end_of_every_command {
    my ($obj) = @_;

    # At the end of every command:
    if ($obj->piped) {

        # Unhook the pipe mechanism now.
        if ( $pager =~ /^\|/ ) {

            # No error from the child.
            $? = 0;

            # we cannot warn here: the handle is missing --tchrist
            close(OUT) || print SAVEOUT "\nCan't close DB::OUT\n";

            # most of the $? crud was coping with broken cshisms
            # $? is explicitly set to 0, so this never runs.
            if ($?) {
                print SAVEOUT "Pager '$pager' failed: ";
                if ( $? == -1 ) {
                    print SAVEOUT "shell returned -1\n";
                }
                elsif ( $? >> 8 ) {
                    print SAVEOUT ( $? & 127 )
                    ? " (SIG#" . ( $? & 127 ) . ")"
                    : "", ( $? & 128 ) ? " -- core dumped" : "", "\n";
                }
                else {
                    print SAVEOUT "status ", ( $? >> 8 ), "\n";
                }
            } ## end if ($?)

            # Reopen filehandle for our output (if we can) and
            # restore STDOUT (if we can).
            open( OUT, ">&STDOUT" ) || _db_warn("Can't restore DB::OUT");
            open( STDOUT, ">&SAVEOUT" )
            || _db_warn("Can't restore STDOUT");

            # Turn off pipe exception handler if necessary.
            $SIG{PIPE} = "DEFAULT" if $SIG{PIPE} eq \&DB::catch;

            # Will stop ignoring SIGPIPE if done like nohup(1)
            # does SIGINT but Perl doesn't give us a choice.
        } ## end if ($pager =~ /^\|/)
        else {

            # Non-piped "pager". Just restore STDOUT.
            open( OUT, ">&SAVEOUT" ) || _db_warn("Can't restore DB::OUT");
        }

        # Let Readline know about the new filehandles.
        reset_IN_OUT( \*IN, \*OUT );

        # Close filehandle pager was using, restore the normal one
        # if necessary,
        close(SAVEOUT);

        if ($obj->selected() ne "") {
            select($obj->selected);
            $obj->selected("");
        }

        # No pipes now.
        $obj->piped("");
    } ## end if ($piped)

    return;
}

sub _DB__handle_watch_expressions
{
    my $self = shift;

    if ( $DB::trace & 2 ) {
        for my $n (0 .. $#DB::to_watch) {
            $DB::evalarg = $DB::to_watch[$n];
            local $DB::onetimeDump;    # Tell DB::eval() to not output results

            # Fix context DB::eval() wants to return an array, but
            # we need a scalar here.
            my ($val) = join( "', '", DB::eval(@_) );
            $val = ( ( defined $val ) ? "'$val'" : 'undef' );

            # Did it change?
            if ( $val ne $DB::old_watch[$n] ) {

                # Yep! Show the difference, and fake an interrupt.
                $DB::signal = 1;
                print {$DB::OUT} <<EOP;
Watchpoint $n:\t$DB::to_watch[$n] changed:
    old value:\t$DB::old_watch[$n]
    new value:\t$val
EOP
                $DB::old_watch[$n] = $val;
            } ## end if ($val ne $old_watch...
        } ## end for my $n (0 ..
    } ## end if ($trace & 2)

    return;
}

=head3 C<_DB__handle_i_command> - inheritance display

Display the (nested) parentage of the module or object given.

=cut

sub _DB__handle_i_command {
    my $self = shift;

    my $line = $self->cmd_args;
    require mro;
    foreach my $isa ( split( /\s+/, $line ) ) {
        $evalarg = "$isa";
        # The &-call is here to ascertain the mutability of @_.
        ($isa) = &DB::eval;
        no strict 'refs';
        print join(
            ', ',
            map {
                "$_"
                  . (
                    defined( ${"$_\::VERSION"} )
                    ? ' ' . ${"$_\::VERSION"}
                    : undef )
              } @{mro::get_linear_isa(ref($isa) || $isa)}
        );
        print "\n";
    }
    next CMD;
}

=head3 C<_cmd_l_main> - list lines (command)

Most of the command is taken up with transforming all the different line
specification syntaxes into 'start-stop'. After that is done, the command
runs a loop over C<@dbline> for the specified range of lines. It handles
the printing of each line and any markers (C<==E<gt>> for current line,
C<b> for break on this line, C<a> for action on this line, C<:> for this
line breakable).

We save the last line listed in the C<$start> global for further listing
later.

=cut

sub _min {
    my $min = shift;
    foreach my $v (@_) {
        if ($min > $v) {
            $min = $v;
        }
    }
    return $min;
}

sub _max {
    my $max = shift;
    foreach my $v (@_) {
        if ($max < $v) {
            $max = $v;
        }
    }
    return $max;
}

sub _minify_to_max {
    my $ref = shift;

    $$ref = _min($$ref, $max);

    return;
}

sub _cmd_l_handle_var_name {
    my $var_name = shift;

    $evalarg = $var_name;

    my ($s) = DB::eval();

    # Ooops. Bad scalar.
    if ($@) {
        print {$OUT} "Error: $@\n";
        next CMD;
    }

    # Good scalar. If it's a reference, find what it points to.
    $s = CvGV_name($s);
    print {$OUT} "Interpreted as: $1 $s\n";
    $line = "$1 $s";

    # Call self recursively to really do the command.
    return _cmd_l_main( $s );
}

sub _cmd_l_handle_subname {

    my $s = $subname;

    # De-Perl4.
    $subname =~ s/\'/::/;

    # Put it in this package unless it starts with ::.
    $subname = $package . "::" . $subname unless $subname =~ /::/;

    # Put it in CORE::GLOBAL if t doesn't start with :: and
    # it doesn't live in this package and it lives in CORE::GLOBAL.
    $subname = "CORE::GLOBAL::$s"
    if not defined &$subname
        and $s !~ /::/
        and defined &{"CORE::GLOBAL::$s"};

    # Put leading '::' names into 'main::'.
    $subname = "main" . $subname if substr( $subname, 0, 2 ) eq "::";

    # Get name:start-stop from find_sub, and break this up at
    # colons.
    my @pieces = split( /:/, find_sub($subname) || $sub{$subname} );

    # Pull off start-stop.
    my $subrange = pop @pieces;

    # If the name contained colons, the split broke it up.
    # Put it back together.
    $file = join( ':', @pieces );

    # If we're not in that file, switch over to it.
    if ( $file ne $filename ) {
        if (! $client_editor) {
            print {$OUT} "Switching to file '$file'.\n";
        }

        # Switch debugger's magic structures.
        *dbline   = $main::{ '_<' . $file };
        $max      = $#dbline;
        $filename = $file;
    } ## end if ($file ne $filename)

    # Subrange is 'start-stop'. If this is less than a window full,
    # swap it to 'start+', which will list a window from the start point.
    if ($subrange) {
        if ( eval($subrange) < -$window ) {
            $subrange =~ s/-.*/+/;
        }

        # Call self recursively to list the range.
        return _cmd_l_main( $subrange );
    } ## end if ($subrange)

    # Couldn't find it.
    else {
        print {$OUT} "Subroutine $subname not found.\n";
        return;
    }
}

sub _cmd_l_empty {
    # Compute new range to list.
    $incr = $window - 1;

    # Recurse to do it.
    return _cmd_l_main( $start . '-' . ( $start + $incr ) );
}

sub _cmd_l_plus {
    my ($new_start, $new_incr) = @_;

    # Don't reset start for 'l +nnn'.
    $start = $new_start if $new_start;

    # Increment for list. Use window size if not specified.
    # (Allows 'l +' to work.)
    $incr = $new_incr || ($window - 1);

    # Create a line range we'll understand, and recurse to do it.
    return _cmd_l_main( $start . '-' . ( $start + $incr ) );
}

sub _cmd_l_calc_initial_end_and_i {
    my ($spec, $start_match, $end_match) = @_;

    # Determine end point; use end of file if not specified.
    my $end = ( !defined $start_match ) ? $max :
    ( $end_match ? $end_match : $start_match );

    # Go on to the end, and then stop.
    _minify_to_max(\$end);

    # Determine start line.
    my $i = $start_match;

    if ($i eq '.') {
        $i = $spec;
    }

    $i = _max($i, 1);

    $incr = $end - $i;

    return ($end, $i);
}

sub _cmd_l_range {
    my ($spec, $current_line, $start_match, $end_match) = @_;

    my ($end, $i) =
        _cmd_l_calc_initial_end_and_i($spec, $start_match, $end_match);

    # If we're running under a client editor, force it to show the lines.
    if ($client_editor) {
        print {$OUT} "$sub_twice$filename:$i:0\n";
        $i = $end;
    }
    # We're doing it ourselves. We want to show the line and special
    # markers for:
    # - the current line in execution
    # - whether a line is breakable or not
    # - whether a line has a break or not
    # - whether a line has an action or not
    else {
        I_TO_END:
        for ( ; $i <= $end ; $i++ ) {

            # Check for breakpoints and actions.
            my ( $stop, $action );
            if ($dbline{$i}) {
                ( $stop, $action ) = split( /\0/, $dbline{$i} );
            }

            # ==> if this is the current line in execution,
            # : if it's breakable.
            my $arrow =
            ( $i == $current_line and $filename eq $filename_ini )
            ? '==>'
            : ( $dbline[$i] + 0 ? ':' : ' ' );

            # Add break and action indicators.
            $arrow .= 'b' if $stop;
            $arrow .= 'a' if $action;

            # Print the line.
            print {$OUT} "$i$arrow\t", $dbline[$i];

            # Move on to the next line. Drop out on an interrupt.
            if ($signal) {
                $i++;
                last I_TO_END;
            }
        } ## end for (; $i <= $end ; $i++)

        # Line the prompt up; print a newline if the last line listed
        # didn't have a newline.
        if ($dbline[ $i - 1 ] !~ /\n\z/) {
            print {$OUT} "\n";
        }
    } ## end else [ if ($client_editor)

    # Save the point we last listed to in case another relative 'l'
    # command is desired. Don't let it run off the end.
    $start = $i;
    _minify_to_max(\$start);

    return;
}

sub _cmd_l_main {
    my $spec = shift;

    # If this is '-something', delete any spaces after the dash.
    $spec =~ s/\A-\s*\z/-/;

    # If the line is '$something', assume this is a scalar containing a
    # line number.
    # Set up for DB::eval() - evaluate in *user* context.
    if ( my ($var_name) = $spec =~ /\A(\$.*)/s ) {
        return _cmd_l_handle_var_name($var_name);
    }
    # l name. Try to find a sub by that name.
    elsif ( ($subname) = $spec =~ /\A([\':A-Za-z_][\':\w]*(?:\[.*\])?)/s ) {
        return _cmd_l_handle_subname();
    }
    # Bare 'l' command.
    elsif ( $spec !~ /\S/ ) {
        return _cmd_l_empty();
    }
    # l [start]+number_of_lines
    elsif ( my ($new_start, $new_incr) = $spec =~ /\A(\d*)\+(\d*)\z/ ) {
        return _cmd_l_plus($new_start, $new_incr);
    }
    # l start-stop or l start,stop
    elsif (my ($s, $e) = $spec =~ /^(?:(-?[\d\$\.]+)(?:[-,]([\d\$\.]+))?)?/ ) {
        return _cmd_l_range($spec, $line, $s, $e);
    }

    return;
} ## end sub _cmd_l_main

sub _DB__handle_l_command {
    my $self = shift;

    _cmd_l_main($self->cmd_args);
    next CMD;
}


# 't' is type.
# 'm' is method.
# 'v' is the value (i.e: method name or subroutine ref).
# 's' is subroutine.
my %cmd_lookup;

BEGIN
{
    %cmd_lookup =
(
    '-' => { t => 'm', v => '_handle_dash_command', },
    '.' => { t => 's', v => \&_DB__handle_dot_command, },
    '=' => { t => 'm', v => '_handle_equal_sign_command', },
    'H' => { t => 'm', v => '_handle_H_command', },
    'S' => { t => 'm', v => '_handle_S_command', },
    'T' => { t => 'm', v => '_handle_T_command', },
    'W' => { t => 'm', v => '_handle_W_command', },
    'c' => { t => 's', v => \&_DB__handle_c_command, },
    'f' => { t => 's', v => \&_DB__handle_f_command, },
    'i' => { t => 's', v => \&_DB__handle_i_command, },
    'l' => { t => 's', v => \&_DB__handle_l_command, },
    'm' => { t => 's', v => \&_DB__handle_m_command, },
    'n' => { t => 'm', v => '_handle_n_command', },
    'p' => { t => 'm', v => '_handle_p_command', },
    'q' => { t => 'm', v => '_handle_q_command', },
    'r' => { t => 'm', v => '_handle_r_command', },
    's' => { t => 'm', v => '_handle_s_command', },
    'save' => { t => 'm', v => '_handle_save_command', },
    'source' => { t => 'm', v => '_handle_source_command', },
    't' => { t => 'm', v => '_handle_t_command', },
    'w' => { t => 'm', v => '_handle_w_command', },
    'x' => { t => 'm', v => '_handle_x_command', },
    'y' => { t => 's', v => \&_DB__handle_y_command, },
    (map { $_ => { t => 'm', v => '_handle_V_command_and_X_command', }, }
        ('X', 'V')),
    (map { $_ => { t => 'm', v => '_handle_enable_disable_commands', }, }
        qw(enable disable)),
    (map { $_ =>
        { t => 's', v => \&_DB__handle_restart_and_rerun_commands, },
        } qw(R rerun)),
    (map { $_ => {t => 'm', v => '_handle_cmd_wrapper_commands' }, }
        qw(a A b B e E h L M o O v w W)),
);
};

sub DB {

    # lock the debugger and get the thread id for the prompt
    lock($DBGR);
    my $tid;
    my $position;
    my ($prefix, $after, $infix);
    my $pat;
    my $explicit_stop;
    my $piped;
    my $selected;

    if ($ENV{PERL5DB_THREADED}) {
        $tid = eval { "[".threads->tid."]" };
    }

    my $cmd_verb;
    my $cmd_args;

    my $obj = DB::Obj->new(
        {
            position => \$position,
            prefix => \$prefix,
            after => \$after,
            explicit_stop => \$explicit_stop,
            infix => \$infix,
            cmd_args => \$cmd_args,
            cmd_verb => \$cmd_verb,
            pat => \$pat,
            piped => \$piped,
            selected => \$selected,
        },
    );

    $obj->_DB_on_init__initialize_globals(@_);

    # Preserve current values of $@, $!, $^E, $,, $/, $\, $^W.
    # The code being debugged may have altered them.
    DB::save();

    # Since DB::DB gets called after every line, we can use caller() to
    # figure out where we last were executing. Sneaky, eh? This works because
    # caller is returning all the extra information when called from the
    # debugger.
    local ( $package, $filename, $line ) = caller;
    $filename_ini = $filename;

    # set up the context for DB::eval, so it can properly execute
    # code on behalf of the user. We add the package in so that the
    # code is eval'ed in the proper package (not in the debugger!).
    local $usercontext = _calc_usercontext($package);

    # Create an alias to the active file magical array to simplify
    # the code here.
    local (*dbline) = $main::{ '_<' . $filename };

    # Last line in the program.
    $max = $#dbline;

    # The &-call is here to ascertain the mutability of @_.
    &_DB__determine_if_we_should_break;

    # Preserve the current stop-or-not, and see if any of the W
    # (watch expressions) has changed.
    my $was_signal = $signal;

    # If we have any watch expressions ...
    _DB__handle_watch_expressions($obj);

=head2 C<watchfunction()>

C<watchfunction()> is a function that can be defined by the user; it is a
function which will be run on each entry to C<DB::DB>; it gets the
current package, filename, and line as its parameters.

The watchfunction can do anything it likes; it is executing in the
debugger's context, so it has access to all of the debugger's internal
data structures and functions.

C<watchfunction()> can control the debugger's actions. Any of the following
will cause the debugger to return control to the user's program after
C<watchfunction()> executes:

=over 4

=item *

Returning a false value from the C<watchfunction()> itself.

=item *

Altering C<$single> to a false value.

=item *

Altering C<$signal> to a false value.

=item *

Turning off the C<4> bit in C<$trace> (this also disables the
check for C<watchfunction()>. This can be done with

    $trace &= ~4;

=back

=cut

    # If there's a user-defined DB::watchfunction, call it with the
    # current package, filename, and line. The function executes in
    # the DB:: package.
    if ( $trace & 4 ) {    # User-installed watch
        return
          if watchfunction( $package, $filename, $line )
          and not $single
          and not $was_signal
          and not( $trace & ~4 );
    } ## end if ($trace & 4)

    # Pick up any alteration to $signal in the watchfunction, and
    # turn off the signal now.
    $was_signal = $signal;
    $signal     = 0;

=head2 GETTING READY TO EXECUTE COMMANDS

The debugger decides to take control if single-step mode is on, the
C<t> command was entered, or the user generated a signal. If the program
has fallen off the end, we set things up so that entering further commands
won't cause trouble, and we say that the program is over.

=cut

    # Make sure that we always print if asked for explicitly regardless
    # of $trace_to_depth .
    $explicit_stop = ($single || $was_signal);

    # Check to see if we should grab control ($single true,
    # trace set appropriately, or we got a signal).
    if ( $explicit_stop || ( $trace & 1 ) ) {
        $obj->_DB__grab_control(@_);
    } ## end if ($single || ($trace...

=pod

If there's an action to be executed for the line we stopped at, execute it.
If there are any preprompt actions, execute those as well.

=cut

    # If there's an action, do it now.
    if ($action) {
        $evalarg = $action;
        # The &-call is here to ascertain the mutability of @_.
        &DB::eval;
    }
    undef $action;

    # Are we nested another level (e.g., did we evaluate a function
    # that had a breakpoint in it at the debugger prompt)?
    if ( $single || $was_signal ) {

        # Yes, go down a level.
        local $level = $level + 1;

        # Do any pre-prompt actions.
        foreach $evalarg (@$pre) {
            # The &-call is here to ascertain the mutability of @_.
            &DB::eval;
        }

        # Complain about too much recursion if we passed the limit.
        if ($single & 4) {
            print $OUT $stack_depth . " levels deep in subroutine calls!\n";
        }

        # The line we're currently on. Set $incr to -1 to stay here
        # until we get a command that tells us to advance.
        $start = $line;
        $incr  = -1;      # for backward motion.

        # Tack preprompt debugger actions ahead of any actual input.
        @typeahead = ( @$pretype, @typeahead );

=head2 WHERE ARE WE?

XXX Relocate this section?

The debugger normally shows the line corresponding to the current line of
execution. Sometimes, though, we want to see the next line, or to move elsewhere
in the file. This is done via the C<$incr>, C<$start>, and C<$max> variables.

C<$incr> controls by how many lines the I<current> line should move forward
after a command is executed. If set to -1, this indicates that the I<current>
line shouldn't change.

C<$start> is the I<current> line. It is used for things like knowing where to
move forwards or backwards from when doing an C<L> or C<-> command.

C<$max> tells the debugger where the last line of the current file is. It's
used to terminate loops most often.

=head2 THE COMMAND LOOP

Most of C<DB::DB> is actually a command parsing and dispatch loop. It comes
in two parts:

=over 4

=item *

The outer part of the loop, starting at the C<CMD> label. This loop
reads a command and then executes it.

=item *

The inner part of the loop, starting at the C<PIPE> label. This part
is wholly contained inside the C<CMD> block and only executes a command.
Used to handle commands running inside a pager.

=back

So why have two labels to restart the loop? Because sometimes, it's easier to
have a command I<generate> another command and then re-execute the loop to do
the new command. This is faster, but perhaps a bit more convoluted.

=cut

        # The big command dispatch loop. It keeps running until the
        # user yields up control again.
        #
        # If we have a terminal for input, and we get something back
        # from readline(), keep on processing.

      CMD:
        while (_DB__read_next_cmd($tid))
        {

            share($cmd);
            # ... try to execute the input as debugger commands.

            # Don't stop running.
            $single = 0;

            # No signal is active.
            $signal = 0;

            # Handle continued commands (ending with \):
            if ($cmd =~ s/\\\z/\n/) {
                $cmd .= DB::readline("  cont: ");
                redo CMD;
            }

=head4 The null command

A newline entered by itself means I<re-execute the last command>. We grab the
command out of C<$laststep> (where it was recorded previously), and copy it
back into C<$cmd> to be executed below. If there wasn't any previous command,
we'll do nothing below (no command will match). If there was, we also save it
in the command history and fall through to allow the command parsing to pick
it up.

=cut

            # Empty input means repeat the last command.
            if ($cmd eq '') {
                $cmd = $laststep;
            }
            chomp($cmd);    # get rid of the annoying extra newline
            if (length($cmd) >= option_val('HistItemMinLength', 2)) {
                push( @hist, $cmd );
            }
            push( @truehist, $cmd );
            share(@hist);
            share(@truehist);

            # This is a restart point for commands that didn't arrive
            # via direct user input. It allows us to 'redo PIPE' to
            # re-execute command processing without reading a new command.
          PIPE: {
                _DB__trim_command_and_return_first_component($obj);

=head3 COMMAND ALIASES

The debugger can create aliases for commands (these are stored in the
C<%alias> hash). Before a command is executed, the command loop looks it up
in the alias hash and substitutes the contents of the alias for the command,
completely replacing it.

=cut

                # See if there's an alias for the command, and set it up if so.
                if ( $alias{$cmd_verb} ) {

                    # Squelch signal handling; we want to keep control here
                    # if something goes loco during the alias eval.
                    local $SIG{__DIE__};
                    local $SIG{__WARN__};

                    # This is a command, so we eval it in the DEBUGGER's
                    # scope! Otherwise, we can't see the special debugger
                    # variables, or get to the debugger's subs. (Well, we
                    # _could_, but why make it even more complicated?)
                    eval "\$cmd =~ $alias{$cmd_verb}";
                    if ($@) {
                        local $\ = '';
                        print $OUT "Couldn't evaluate '$cmd_verb' alias: $@";
                        next CMD;
                    }
                    _DB__trim_command_and_return_first_component($obj);
                } ## end if ($alias{$cmd_verb})

=head3 MAIN-LINE COMMANDS

All of these commands work up to and after the program being debugged has
terminated.

=head4 C<q> - quit

Quit the debugger. This entails setting the C<$fall_off_end> flag, so we don't
try to execute further, cleaning any restart-related stuff out of the
environment, and executing with the last value of C<$?>.

=cut

                # All of these commands were remapped in perl 5.8.0;
                # we send them off to the secondary dispatcher (see below).
                $obj->_handle_special_char_cmd_wrapper_commands;
                _DB__trim_command_and_return_first_component($obj);

                if (my $cmd_rec = $cmd_lookup{$cmd_verb}) {
                    my $type = $cmd_rec->{t};
                    my $val = $cmd_rec->{v};
                    if ($type eq 'm') {
                        $obj->$val();
                    }
                    elsif ($type eq 's') {
                        $val->($obj);
                    }
                }

=head4 C<t> - trace [n]

Turn tracing on or off. Inverts the appropriate bit in C<$trace> (q.v.).
If level is specified, set C<$trace_to_depth>.

=head4 C<S> - list subroutines matching/not matching a pattern

Walks through C<%sub>, checking to see whether or not to print the name.

=head4 C<X> - list variables in current package

Since the C<V> command actually processes this, just change this to the
appropriate C<V> command and fall through.

=head4 C<V> - list variables

Uses C<dumpvar.pl> to dump out the current values for selected variables.

=head4 C<x> - evaluate and print an expression

Hands the expression off to C<DB::eval>, setting it up to print the value
via C<dumpvar.pl> instead of just printing it directly.

=head4 C<m> - print methods

Just uses C<DB::methods> to determine what methods are available.

=head4 C<f> - switch files

Switch to a different filename.

=head4 C<.> - return to last-executed line.

We set C<$incr> to -1 to indicate that the debugger shouldn't move ahead,
and then we look up the line in the magical C<%dbline> hash.

=head4 C<-> - back one window

We change C<$start> to be one window back; if we go back past the first line,
we set it to be the first line. We set C<$incr> to put us back at the
currently-executing line, and then put a S<C<l $start +>> (list one window from
C<$start>) in C<$cmd> to be executed later.

=head3 PRE-580 COMMANDS VS. NEW COMMANDS: C<a, A, b, B, h, l, L, M, o, O, P, v, w, W, E<lt>, E<lt>E<lt>, E<0x7B>, E<0x7B>E<0x7B>>

In Perl 5.8.0, a realignment of the commands was done to fix up a number of
problems, most notably that the default case of several commands destroying
the user's work in setting watchpoints, actions, etc. We wanted, however, to
retain the old commands for those who were used to using them or who preferred
them. At this point, we check for the new commands and call C<cmd_wrapper> to
deal with them instead of processing them in-line.

=head4 C<y> - List lexicals in higher scope

Uses C<PadWalker> to find the lexicals supplied as arguments in a scope
above the current one and then displays then using C<dumpvar.pl>.

=head3 COMMANDS NOT WORKING AFTER PROGRAM ENDS

All of the commands below this point don't work after the program being
debugged has ended. All of them check to see if the program has ended; this
allows the commands to be relocated without worrying about a 'line of
demarcation' above which commands can be entered anytime, and below which
they can't.

=head4 C<n> - single step, but don't trace down into subs

Done by setting C<$single> to 2, which forces subs to execute straight through
when entered (see C<DB::sub> in L</DEBUGGER INTERFACE VARIABLES>). We also
save the C<n> command in C<$laststep>,

so a null command knows what to re-execute.

=head4 C<s> - single-step, entering subs

Sets C<$single> to 1, which causes C<DB::sub> to continue tracing inside
subs. Also saves C<s> as C<$lastcmd>.

=head4 C<c> - run continuously, setting an optional breakpoint

Most of the code for this command is taken up with locating the optional
breakpoint, which is either a subroutine name or a line number. We set
the appropriate one-time-break in C<@dbline> and then turn off single-stepping
in this and all call levels above this one.

=head4 C<r> - return from a subroutine

For C<r> to work properly, the debugger has to stop execution again
immediately after the return is executed. This is done by forcing
single-stepping to be on in the call level above the current one. If
we are printing return values when a C<r> is executed, set C<$doret>
appropriately, and force us out of the command loop.

=head4 C<T> - stack trace

Just calls C<DB::print_trace>.

=head4 C<w> - List window around current line.

Just calls C<DB::cmd_w>.

=head4 C<W> - watch-expression processing.

Just calls C<DB::cmd_W>.

=head4 C</> - search forward for a string in the source

We take the argument and treat it as a pattern. If it turns out to be a
bad one, we return the error we got from trying to C<eval> it and exit.
If not, we create some code to do the search and C<eval> it so it can't
mess us up.

=cut

                _DB__handle_forward_slash_command($obj);

=head4 C<?> - search backward for a string in the source

Same as for C</>, except the loop runs backwards.

=cut

                _DB__handle_question_mark_command($obj);

=head4 C<$rc> - Recall command

Manages the commands in C<@hist> (which is created if C<Term::ReadLine> reports
that the terminal supports history). It finds the command required, puts it
into C<$cmd>, and redoes the loop to execute it.

=cut

                # $rc - recall command.
                $obj->_handle_rc_recall_command;

=head4 C<$sh$sh> - C<system()> command

Calls the C<_db_system()> to handle the command. This keeps the C<STDIN> and
C<STDOUT> from getting messed up.

=cut

                $obj->_handle_sh_command;

=head4 C<$rc I<pattern> $rc> - Search command history

Another command to manipulate C<@hist>: this one searches it with a pattern.
If a command is found, it is placed in C<$cmd> and executed via C<redo>.

=cut

                $obj->_handle_rc_search_history_command;

=head4 C<$sh> - Invoke a shell

Uses C<_db_system()> to invoke a shell.

=cut

=head4 C<$sh I<command>> - Force execution of a command in a shell

Like the above, but the command is passed to the shell. Again, we use
C<_db_system()> to avoid problems with C<STDIN> and C<STDOUT>.

=head4 C<H> - display commands in history

Prints the contents of C<@hist> (if any).

=head4 C<man, doc, perldoc> - look up documentation

Just calls C<runman()> to print the appropriate document.

=cut

                $obj->_handle_doc_command;

=head4 C<p> - print

Builds a C<print EXPR> expression in the C<$cmd>; this will get executed at
the bottom of the loop.

=head4 C<=> - define command alias

Manipulates C<%alias> to add or list command aliases.

=head4 C<source> - read commands from a file.

Opens a lexical filehandle and stacks it on C<@cmdfhs>; C<DB::readline> will
pick it up.

=head4 C<enable> C<disable> - enable or disable breakpoints

This enables or disables breakpoints.

=head4 C<save> - send current history to a file

Takes the complete history, (not the shrunken version you see with C<H>),
and saves it to the given filename, so it can be replayed using C<source>.

Note that all C<^(save|source)>'s are commented out with a view to minimise recursion.

=head4 C<R> - restart

Restart the debugger session.

=head4 C<rerun> - rerun the current session

Return to any given position in the B<true>-history list

=head4 C<|, ||> - pipe output through the pager.

For C<|>, we save C<OUT> (the debugger's output filehandle) and C<STDOUT>
(the program's standard output). For C<||>, we only save C<OUT>. We open a
pipe to the pager (restoring the output filehandles if this fails). If this
is the C<|> command, we also set up a C<SIGPIPE> handler which will simply
set C<$signal>, sending us back into the debugger.

We then trim off the pipe symbols and C<redo> the command loop at the
C<PIPE> label, causing us to evaluate the command in C<$cmd> without
reading another.

=cut

                # || - run command in the pager, with output to DB::OUT.
                _DB__handle_run_command_in_pager_command($obj);

=head3 END OF COMMAND PARSING

Anything left in C<$cmd> at this point is a Perl expression that we want to
evaluate. We'll always evaluate in the user's context, and fully qualify
any variables we might want to address in the C<DB> package.

=cut

            }    # PIPE:

            # trace an expression
            $cmd =~ s/^t\s/\$DB::trace |= 1;\n/;

            # Make sure the flag that says "the debugger's running" is
            # still on, to make sure we get control again.
            $evalarg = "\$^D = \$^D | \$DB::db_stop;\n$cmd";

            # Run *our* eval that executes in the caller's context.
            # The &-call is here to ascertain the mutability of @_.
            &DB::eval;

            # Turn off the one-time-dump stuff now.
            if ($onetimeDump) {
                $onetimeDump      = undef;
                $onetimedumpDepth = undef;
            }
            elsif ( $term_pid == $$ ) {
                eval { # May run under miniperl, when not available...
                    STDOUT->flush();
                    STDERR->flush();
                };

                # XXX If this is the master pid, print a newline.
                print {$OUT} "\n";
            }
        } ## end while (($term || &setterm...

=head3 POST-COMMAND PROCESSING

After each command, we check to see if the command output was piped anywhere.
If so, we go through the necessary code to unhook the pipe and go back to
our standard filehandles for input and output.

=cut

        continue {    # CMD:
            _DB__at_end_of_every_command($obj);
        }    # CMD:

=head3 COMMAND LOOP TERMINATION

When commands have finished executing, we come here. If the user closed the
input filehandle, we turn on C<$fall_off_end> to emulate a C<q> command. We
evaluate any post-prompt items. We restore C<$@>, C<$!>, C<$^E>, C<$,>, C<$/>,
C<$\>, and C<$^W>, and return a null list as expected by the Perl interpreter.
The interpreter will then execute the next line and then return control to us
again.

=cut

        # No more commands? Quit.
        $fall_off_end = 1 unless defined $cmd;    # Emulate 'q' on EOF

        # Evaluate post-prompt commands.
        foreach $evalarg (@$post) {
            # The &-call is here to ascertain the mutability of @_.
            &DB::eval;
        }
    }    # if ($single || $signal)

    # Put the user's globals back where you found them.
    ( $@, $!, $^E, $,, $/, $\, $^W ) = @saved;
    ();
} ## end sub DB

# Because DB::Obj is used above,
#
#   my $obj = DB::Obj->new(
#
# The following package declaration must come before that,
# or else runtime errors will occur with
#
#   PERLDB_OPTS="autotrace nonstop"
#
# ( rt#116771 )
BEGIN {

package DB::Obj;

sub new {
    my $class = shift;

    my $self = bless {}, $class;

    $self->_init(@_);

    return $self;
}

sub _init {
    my ($self, $args) = @_;

    %{$self} = (%$self, %$args);

    return;
}

{
    no strict 'refs';
    foreach my $slot_name (qw(
        after explicit_stop infix pat piped position prefix selected cmd_verb
        cmd_args
        )) {
        my $slot = $slot_name;
        *{$slot} = sub {
            my $self = shift;

            if (@_) {
                ${ $self->{$slot} } = shift;
            }

            return ${ $self->{$slot} };
        };

        *{"append_to_$slot"} = sub {
            my $self = shift;
            my $s = shift;

            return $self->$slot($self->$slot . $s);
        };
    }
}

sub _DB_on_init__initialize_globals
{
    my $self = shift;

    # Check for whether we should be running continuously or not.
    # _After_ the perl program is compiled, $single is set to 1:
    if ( $single and not $second_time++ ) {

        # Options say run non-stop. Run until we get an interrupt.
        if ($runnonstop) {    # Disable until signal
                # If there's any call stack in place, turn off single
                # stepping into subs throughout the stack.
            for my $i (0 .. $stack_depth) {
                $stack[ $i ] &= ~1;
            }

            # And we are now no longer in single-step mode.
            $single = 0;

            # If we simply returned at this point, we wouldn't get
            # the trace info. Fall on through.
            # return;
        } ## end if ($runnonstop)

        elsif ($ImmediateStop) {

            # We are supposed to stop here; XXX probably a break.
            $ImmediateStop = 0;    # We've processed it; turn it off
            $signal        = 1;    # Simulate an interrupt to force
                                   # us into the command loop
        }
    } ## end if ($single and not $second_time...

    # If we're in single-step mode, or an interrupt (real or fake)
    # has occurred, turn off non-stop mode.
    $runnonstop = 0 if $single or $signal;

    return;
}

sub _my_print_lineinfo
{
    my ($self, $i, $incr_pos) = @_;

    if ($frame) {
        # Print it indented if tracing is on.
        DB::print_lineinfo( ' ' x $stack_depth,
            "$i:\t$DB::dbline[$i]" . $self->after );
    }
    else {
        DB::depth_print_lineinfo($self->explicit_stop, $incr_pos);
    }
}

sub _curr_line {
    return $DB::dbline[$line];
}

sub _is_full {
    my ($self, $letter) = @_;

    return ($DB::cmd eq $letter);
}

sub _DB__grab_control
{
    my $self = shift;

    # Yes, grab control.
    if ($client_editor) {

        # Tell the editor to update its position.
        $self->position("$sub_twice${DB::filename}:$line:0\n");
        DB::print_lineinfo($self->position());
    }

=pod

Special check: if we're in package C<DB::fake>, we've gone through the
C<END> block at least once. We set up everything so that we can continue
to enter commands and have a valid context to be in.

=cut

    elsif ( $DB::package eq 'DB::fake' ) {

        # Fallen off the end already.
        if (!$DB::term) {
            DB::setterm();
        }

        DB::print_help(<<EOP);
Debugged program terminated.  Use B<q> to quit or B<R> to restart,
use B<o> I<inhibit_exit> to avoid stopping after program termination,
S<B<h q>>, S<B<h R>> or S<B<h o>> to get additional info.
EOP

        $DB::package     = 'main';
        $DB::usercontext = DB::_calc_usercontext($DB::package);
    } ## end elsif ($package eq 'DB::fake')

=pod

If the program hasn't finished executing, we scan forward to the
next executable line, print that out, build the prompt from the file and line
number information, and print that.

=cut

    else {


        # Still somewhere in the midst of execution. Set up the
        #  debugger prompt.
        $DB::sub =~ s/\'/::/;    # Swap Perl 4 package separators (') to
                             # Perl 5 ones (sorry, we don't print Klingon
                             #module names)

        $self->prefix($DB::sub =~ /::/ ? "" : ($DB::package . '::'));
        $self->append_to_prefix( "$DB::sub(${DB::filename}:" );
        $self->after( $self->_curr_line =~ /\n$/ ? '' : "\n" );

        # Break up the prompt if it's really long.
        if ( length($self->prefix()) > 30 ) {
            $self->position($self->prefix . "$line):\n$line:\t" . $self->_curr_line . $self->after);
            $self->prefix("");
            $self->infix(":\t");
        }
        else {
            $self->infix("):\t");
            $self->position(
                $self->prefix . $line. $self->infix
                . $self->_curr_line . $self->after
            );
        }

        # Print current line info, indenting if necessary.
        $self->_my_print_lineinfo($line, $self->position);

        my $i;
        my $line_i = sub { return $DB::dbline[$i]; };

        # Scan forward, stopping at either the end or the next
        # unbreakable line.
        for ( $i = $line + 1 ; $i <= $DB::max && $line_i->() == 0 ; ++$i )
        {    #{ vi

            # Drop out on null statements, block closers, and comments.
            last if $line_i->() =~ /^\s*[\;\}\#\n]/;

            # Drop out if the user interrupted us.
            last if $signal;

            # Append a newline if the line doesn't have one. Can happen
            # in eval'ed text, for instance.
            $self->after( $line_i->() =~ /\n$/ ? '' : "\n" );

            # Next executable line.
            my $incr_pos = $self->prefix . $i . $self->infix . $line_i->()
                . $self->after;
            $self->append_to_position($incr_pos);
            $self->_my_print_lineinfo($i, $incr_pos);
        } ## end for ($i = $line + 1 ; $i...
    } ## end else [ if ($client_editor)

    return;
}

sub _handle_t_command {
    my $self = shift;

    my $levels = $self->cmd_args();

    if ((!length($levels)) or ($levels !~ /\D/)) {
        $trace ^= 1;
        local $\ = '';
        $DB::trace_to_depth = $levels ? $stack_depth + $levels : 1E9;
        print {$OUT} "Trace = "
        . ( ( $trace & 1 )
            ? ( $levels ? "on (to level $DB::trace_to_depth)" : "on" )
            : "off" ) . "\n";
        next CMD;
    }

    return;
}


sub _handle_S_command {
    my $self = shift;

    if (my ($print_all_subs, $should_reverse, $Spatt)
        = $self->cmd_args =~ /\A((!)?(.+))?\z/) {
        # $Spatt is the pattern (if any) to use.
        # Reverse scan?
        my $Srev     = defined $should_reverse;
        # No args - print all subs.
        my $Snocheck = !defined $print_all_subs;

        # Need to make these sane here.
        local $\ = '';
        local $, = '';

        # Search through the debugger's magical hash of subs.
        # If $nocheck is true, just print the sub name.
        # Otherwise, check it against the pattern. We then use
        # the XOR trick to reverse the condition as required.
        foreach $subname ( sort( keys %sub ) ) {
            if ( $Snocheck or $Srev ^ ( $subname =~ /$Spatt/ ) ) {
                print $OUT $subname, "\n";
            }
        }
        next CMD;
    }

    return;
}

sub _handle_V_command_and_X_command {
    my $self = shift;

    $DB::cmd =~ s/^X\b/V $DB::package/;

    # Bare V commands get the currently-being-debugged package
    # added.
    if ($self->_is_full('V')) {
        $DB::cmd = "V $DB::package";
    }

    # V - show variables in package.
    if (my ($new_packname, $new_vars_str) =
        $DB::cmd =~ /\AV\b\s*(\S+)\s*(.*)/) {

        # Save the currently selected filehandle and
        # force output to debugger's filehandle (dumpvar
        # just does "print" for output).
        my $savout = select($OUT);

        # Grab package name and variables to dump.
        $packname = $new_packname;
        my @vars     = split( ' ', $new_vars_str );

        # If main::dumpvar isn't here, get it.
        do 'dumpvar.pl' || die $@ unless defined &main::dumpvar;
        if ( defined &main::dumpvar ) {

            # We got it. Turn off subroutine entry/exit messages
            # for the moment, along with return values.
            local $frame = 0;
            local $doret = -2;

            # must detect sigpipe failures  - not catching
            # then will cause the debugger to die.
            eval {
                main::dumpvar(
                    $packname,
                    defined $option{dumpDepth}
                    ? $option{dumpDepth}
                    : -1,    # assume -1 unless specified
                    @vars
                );
            };

            # The die doesn't need to include the $@, because
            # it will automatically get propagated for us.
            if ($@) {
                die unless $@ =~ /dumpvar print failed/;
            }
        } ## end if (defined &main::dumpvar)
        else {

            # Couldn't load dumpvar.
            print $OUT "dumpvar.pl not available.\n";
        }

        # Restore the output filehandle, and go round again.
        select($savout);
        next CMD;
    }

    return;
}

sub _handle_dash_command {
    my $self = shift;

    if ($self->_is_full('-')) {

        # back up by a window; go to 1 if back too far.
        $start -= $incr + $window + 1;
        $start = 1 if $start <= 0;
        $incr  = $window - 1;

        # Generate and execute a "l +" command (handled below).
        $DB::cmd = 'l ' . ($start) . '+';
        redo CMD;
    }
    return;
}

sub _n_or_s_commands_generic {
    my ($self, $new_val) = @_;
    # n - next
    next CMD if DB::_DB__is_finished();

    # Single step, but don't enter subs.
    $single = $new_val;

    # Save for empty command (repeat last).
    $laststep = $DB::cmd;
    last CMD;
}

sub _n_or_s {
    my ($self, $letter, $new_val) = @_;

    if ($self->_is_full($letter)) {
        $self->_n_or_s_commands_generic($new_val);
    }
    else {
        $self->_n_or_s_and_arg_commands_generic($letter, $new_val);
    }

    return;
}

sub _handle_n_command {
    my $self = shift;

    return $self->_n_or_s('n', 2);
}

sub _handle_s_command {
    my $self = shift;

    return $self->_n_or_s('s', 1);
}

sub _handle_r_command {
    my $self = shift;

    # r - return from the current subroutine.
    if ($self->_is_full('r')) {

        # Can't do anything if the program's over.
        next CMD if DB::_DB__is_finished();

        # Turn on stack trace.
        $stack[$stack_depth] |= 1;

        # Print return value unless the stack is empty.
        $doret = $option{PrintRet} ? $stack_depth - 1 : -2;
        last CMD;
    }

    return;
}

sub _handle_T_command {
    my $self = shift;

    if ($self->_is_full('T')) {
        DB::print_trace( $OUT, 1 );    # skip DB
        next CMD;
    }

    return;
}

sub _handle_w_command {
    my $self = shift;

    DB::cmd_w( 'w', $self->cmd_args() );
    next CMD;

    return;
}

sub _handle_W_command {
    my $self = shift;

    if (my $arg = $self->cmd_args) {
        DB::cmd_W( 'W', $arg );
        next CMD;
    }

    return;
}

sub _handle_rc_recall_command {
    my $self = shift;

    # $rc - recall command.
    if (my ($minus, $arg) = $DB::cmd =~ m#\A$rc+\s*(-)?(\d+)?\z#) {

        # No arguments, take one thing off history.
        pop(@hist) if length($DB::cmd) > 1;

        # Relative (- found)?
        #  Y - index back from most recent (by 1 if bare minus)
        #  N - go to that particular command slot or the last
        #      thing if nothing following.

        $self->cmd_verb(
            scalar($minus ? ( $#hist - ( $arg || 1 ) ) : ( $arg || $#hist ))
        );

        # Pick out the command desired.
        $DB::cmd = $hist[$self->cmd_verb];

        # Print the command to be executed and restart the loop
        # with that command in the buffer.
        print {$OUT} $DB::cmd, "\n";
        redo CMD;
    }

    return;
}

sub _handle_rc_search_history_command {
    my $self = shift;

    # $rc pattern $rc - find a command in the history.
    if (my ($arg) = $DB::cmd =~ /\A$rc([^$rc].*)\z/) {

        # Create the pattern to use.
        my $pat = "^$arg";
        $self->pat($pat);

        # Toss off last entry if length is >1 (and it always is).
        pop(@hist) if length($DB::cmd) > 1;

        my $i;

        # Look backward through the history.
        SEARCH_HIST:
        for ( $i = $#hist ; $i ; --$i ) {
            # Stop if we find it.
            last SEARCH_HIST if $hist[$i] =~ /$pat/;
        }

        if ( !$i ) {

            # Never found it.
            print $OUT "No such command!\n\n";
            next CMD;
        }

        # Found it. Put it in the buffer, print it, and process it.
        $DB::cmd = $hist[$i];
        print $OUT $DB::cmd, "\n";
        redo CMD;
    }

    return;
}

sub _handle_H_command {
    my $self = shift;

    if ($self->cmd_args =~ m#\A\*#) {
        @hist = @truehist = ();
        print $OUT "History cleansed\n";
        next CMD;
    }

    if (my ($num) = $self->cmd_args =~ /\A(?:-(\d+))?/) {

        # Anything other than negative numbers is ignored by
        # the (incorrect) pattern, so this test does nothing.
        $end = $num ? ( $#hist - $num ) : 0;

        # Set to the minimum if less than zero.
        $hist = 0 if $hist < 0;

        # Start at the end of the array.
        # Stay in while we're still above the ending value.
        # Tick back by one each time around the loop.
        my $i;

        for ( $i = $#hist ; $i > $end ; $i-- ) {
            print $OUT "$i: ", $hist[$i], "\n";
        }

        next CMD;
    }

    return;
}

sub _handle_doc_command {
    my $self = shift;

    # man, perldoc, doc - show manual pages.
    if (my ($man_page)
        = $DB::cmd =~ /\A(?:man|(?:perl)?doc)\b(?:\s+([^(]*))?\z/) {
        DB::runman($man_page);
        next CMD;
    }

    return;
}

sub _handle_p_command {
    my $self = shift;

    my $print_cmd = 'print {$DB::OUT} ';
    # p - print (no args): print $_.
    if ($self->_is_full('p')) {
        $DB::cmd = $print_cmd . '$_';
    }
    else {
        # p - print the given expression.
        $DB::cmd =~ s/\Ap\b/$print_cmd /;
    }

    return;
}

sub _handle_equal_sign_command {
    my $self = shift;

    if ($DB::cmd =~ s/\A=\s*//) {
        my @keys;
        if ( length $DB::cmd == 0 ) {

            # No args, get current aliases.
            @keys = sort keys %alias;
        }
        elsif ( my ( $k, $v ) = ( $DB::cmd =~ /^(\S+)\s+(\S.*)/ ) ) {

            # Creating a new alias. $k is alias name, $v is
            # alias value.

            # can't use $_ or kill //g state
            for my $x ( $k, $v ) {

                # Escape "alarm" characters.
                $x =~ s/\a/\\a/g;
            }

            # Substitute key for value, using alarm chars
            # as separators (which is why we escaped them in
            # the command).
            $alias{$k} = "s\a$k\a$v\a";

            # Turn off standard warn and die behavior.
            local $SIG{__DIE__};
            local $SIG{__WARN__};

            # Is it valid Perl?
            unless ( eval "sub { s\a$k\a$v\a }; 1" ) {

                # Nope. Bad alias. Say so and get out.
                print $OUT "Can't alias $k to $v: $@\n";
                delete $alias{$k};
                next CMD;
            }

            # We'll only list the new one.
            @keys = ($k);
        } ## end elsif (my ($k, $v) = ($DB::cmd...

        # The argument is the alias to list.
        else {
            @keys = ($DB::cmd);
        }

        # List aliases.
        for my $k (@keys) {

            # Messy metaquoting: Trim the substitution code off.
            # We use control-G as the delimiter because it's not
            # likely to appear in the alias.
            if ( ( my $v = $alias{$k} ) =~ ss\a$k\a(.*)\a$1 ) {

                # Print the alias.
                print $OUT "$k\t= $1\n";
            }
            elsif ( defined $alias{$k} ) {

                # Couldn't trim it off; just print the alias code.
                print $OUT "$k\t$alias{$k}\n";
            }
            else {

                # No such, dude.
                print "No alias for $k\n";
            }
        } ## end for my $k (@keys)
        next CMD;
    }

    return;
}

sub _handle_source_command {
    my $self = shift;

    # source - read commands from a file (or pipe!) and execute.
    if (my $sourced_fn = $self->cmd_args) {
        if ( open my $fh, $sourced_fn ) {

            # Opened OK; stick it in the list of file handles.
            push @cmdfhs, $fh;
        }
        else {

            # Couldn't open it.
            DB::_db_warn("Can't execute '$sourced_fn': $!\n");
        }
        next CMD;
    }

    return;
}

sub _handle_enable_disable_commands {
    my $self = shift;

    my $which_cmd = $self->cmd_verb;
    my $position = $self->cmd_args;

    if ($position !~ /\s/) {
        my ($fn, $line_num);
        if ($position =~ m{\A\d+\z})
        {
            $fn = $DB::filename;
            $line_num = $position;
        }
        elsif (my ($new_fn, $new_line_num)
            = $position =~ m{\A(.*):(\d+)\z}) {
            ($fn, $line_num) = ($new_fn, $new_line_num);
        }
        else
        {
            DB::_db_warn("Wrong spec for enable/disable argument.\n");
        }

        if (defined($fn)) {
            if (DB::_has_breakpoint_data_ref($fn, $line_num)) {
                DB::_set_breakpoint_enabled_status($fn, $line_num,
                    ($which_cmd eq 'enable' ? 1 : '')
                );
            }
            else {
                DB::_db_warn("No breakpoint set at ${fn}:${line_num}\n");
            }
        }

        next CMD;
    }

    return;
}

sub _handle_save_command {
    my $self = shift;

    if (my $new_fn = $self->cmd_args) {
        my $filename = $new_fn || '.perl5dbrc';    # default?
        if ( open my $fh, '>', $filename ) {

            # chomp to remove extraneous newlines from source'd files
            chomp( my @truelist =
                map { m/\A\s*(save|source)/ ? "#$_" : $_ }
                @truehist );
            print {$fh} join( "\n", @truelist );
            print "commands saved in $filename\n";
        }
        else {
            DB::_db_warn("Can't save debugger commands in '$new_fn': $!\n");
        }
        next CMD;
    }

    return;
}

sub _n_or_s_and_arg_commands_generic {
    my ($self, $letter, $new_val) = @_;

    # s - single-step. Remember the last command was 's'.
    if ($DB::cmd =~ s#\A\Q$letter\E\s#\$DB::single = $new_val;\n#) {
        $laststep = $letter;
    }

    return;
}

sub _handle_sh_command {
    my $self = shift;

    # $sh$sh - run a shell command (if it's all ASCII).
    # Can't run shell commands with Unicode in the debugger, hmm.
    my $my_cmd = $DB::cmd;
    if ($my_cmd =~ m#\A$sh#gms) {

        if ($my_cmd =~ m#\G\z#cgms) {
            # Run the user's shell. If none defined, run Bourne.
            # We resume execution when the shell terminates.
            DB::_db_system( $ENV{SHELL} || "/bin/sh" );
            next CMD;
        }
        elsif ($my_cmd =~ m#\G$sh\s*(.*)#cgms) {
            # System it.
            DB::_db_system($1);
            next CMD;
        }
        elsif ($my_cmd =~ m#\G\s*(.*)#cgms) {
            DB::_db_system( $ENV{SHELL} || "/bin/sh", "-c", $1 );
            next CMD;
        }
    }
}

sub _handle_x_command {
    my $self = shift;

    if ($DB::cmd =~ s#\Ax\b# #) {    # Remainder gets done by DB::eval()
        $onetimeDump = 'dump';    # main::dumpvar shows the output

        # handle special  "x 3 blah" syntax XXX propagate
        # doc back to special variables.
        if ( $DB::cmd =~ s#\A\s*(\d+)(?=\s)# #) {
            $onetimedumpDepth = $1;
        }
    }

    return;
}

sub _handle_q_command {
    my $self = shift;

    if ($self->_is_full('q')) {
        $fall_off_end = 1;
        DB::clean_ENV();
        exit $?;
    }

    return;
}

sub _handle_cmd_wrapper_commands {
    my $self = shift;

    DB::cmd_wrapper( $self->cmd_verb, $self->cmd_args, $line );
    next CMD;
}

sub _handle_special_char_cmd_wrapper_commands {
    my $self = shift;

    # All of these commands were remapped in perl 5.8.0;
    # we send them off to the secondary dispatcher (see below).
    if (my ($cmd_letter, $my_arg) = $DB::cmd =~ /\A([<>\{]{1,2})\s*(.*)/so) {
        DB::cmd_wrapper( $cmd_letter, $my_arg, $line );
        next CMD;
    }

    return;
}

} ## end DB::Obj

package DB;

# The following code may be executed now:
# BEGIN {warn 4}

=head2 sub

C<sub> is called whenever a subroutine call happens in the program being
debugged. The variable C<$DB::sub> contains the name of the subroutine
being called.

The core function of this subroutine is to actually call the sub in the proper
context, capturing its output. This of course causes C<DB::DB> to get called
again, repeating until the subroutine ends and returns control to C<DB::sub>
again. Once control returns, C<DB::sub> figures out whether or not to dump the
return value, and returns its captured copy of the return value as its own
return value. The value then feeds back into the program being debugged as if
C<DB::sub> hadn't been there at all.

C<sub> does all the work of printing the subroutine entry and exit messages
enabled by setting C<$frame>. It notes what sub the autoloader got called for,
and also prints the return value if needed (for the C<r> command and if
the 16 bit is set in C<$frame>).

It also tracks the subroutine call depth by saving the current setting of
C<$single> in the C<@stack> package global; if this exceeds the value in
C<$deep>, C<sub> automatically turns on printing of the current depth by
setting the C<4> bit in C<$single>. In any case, it keeps the current setting
of stop/don't stop on entry to subs set as it currently is set.

=head3 C<caller()> support

If C<caller()> is called from the package C<DB>, it provides some
additional data, in the following order:

=over 4

=item * C<$package>

The package name the sub was in

=item * C<$filename>

The filename it was defined in

=item * C<$line>

The line number it was defined on

=item * C<$subroutine>

The subroutine name; C<(eval)> if an C<eval>().

=item * C<$hasargs>

1 if it has arguments, 0 if not

=item * C<$wantarray>

1 if array context, 0 if scalar context

=item * C<$evaltext>

The C<eval>() text, if any (undefined for S<C<eval BLOCK>>)

=item * C<$is_require>

frame was created by a C<use> or C<require> statement

=item * C<$hints>

pragma information; subject to change between versions

=item * C<$bitmask>

pragma information; subject to change between versions

=item * C<@DB::args>

arguments with which the subroutine was invoked

=back

=cut

use vars qw($deep);

# We need to fully qualify the name ("DB::sub") to make "use strict;"
# happy. -- Shlomi Fish

sub _indent_print_line_info {
    my ($offset, $str) = @_;

    print_lineinfo( ' ' x ($stack_depth - $offset), $str);

    return;
}

sub _print_frame_message {
    my ($al) = @_;

    if ($frame) {
        if ($frame & 4) {   # Extended frame entry message
            _indent_print_line_info(-1, "in  ");

            # Why -1? But it works! :-(
            # Because print_trace will call add 1 to it and then call
            # dump_trace; this results in our skipping -1+1 = 0 stack frames
            # in dump_trace.
            #
            # Now it's 0 because we extracted a function.
            print_trace( $LINEINFO, 0, 1, 1, "$sub$al" );
        }
        else {
            _indent_print_line_info(-1, "entering $sub$al\n" );
        }
    }

    return;
}

sub DB::sub {
    my ( $al, $ret, @ret ) = "";

    # We stack the stack pointer and then increment it to protect us
    # from a situation that might unwind a whole bunch of call frames
    # at once. Localizing the stack pointer means that it will automatically
    # unwind the same amount when multiple stack frames are unwound.
    local $stack_depth = $stack_depth + 1;    # Protect from non-local exits

    {
        # lock ourselves under threads
        # While lock() permits recursive locks, there's two cases where it's bad
        # that we keep a hold on the lock while we call the sub:
        #  - during cloning, Package::CLONE might be called in the context of the new
        #    thread, which will deadlock if we hold the lock across the threads::new call
        #  - for any function that waits any significant time
        # This also deadlocks if the parent thread joins(), since holding the lock
        # will prevent any child threads passing this point.
        # So release the lock for the function call.
        lock($DBGR);

        # Whether or not the autoloader was running, a scalar to put the
        # sub's return value in (if needed), and an array to put the sub's
        # return value in (if needed).
        if ($sub eq 'threads::new' && $ENV{PERL5DB_THREADED}) {
            print "creating new thread\n";
        }

        # If the last ten characters are '::AUTOLOAD', note we've traced
        # into AUTOLOAD for $sub.
        if ( length($sub) > 10 && substr( $sub, -10, 10 ) eq '::AUTOLOAD' ) {
            no strict 'refs';
            $al = " for $$sub" if defined $$sub;
        }

        # Expand @stack.
        $#stack = $stack_depth;

        # Save current single-step setting.
        $stack[-1] = $single;

        # Turn off all flags except single-stepping.
        $single &= 1;

        # If we've gotten really deeply recursed, turn on the flag that will
        # make us stop with the 'deep recursion' message.
        $single |= 4 if $stack_depth == $deep;

        # If frame messages are on ...

        _print_frame_message($al);
    }

    # Determine the sub's return type, and capture appropriately.
    if (wantarray) {

        # Called in array context. call sub and capture output.
        # DB::DB will recursively get control again if appropriate; we'll come
        # back here when the sub is finished.
        no strict 'refs';
        @ret = &$sub;
    }
    elsif ( defined wantarray ) {
        no strict 'refs';
        # Save the value if it's wanted at all.
        $ret = &$sub;
    }
    else {
        no strict 'refs';
        # Void return, explicitly.
        &$sub;
        undef $ret;
    }

    {
        lock($DBGR);

        # Pop the single-step value back off the stack.
        $single |= $stack[ $stack_depth-- ];

        if ($frame & 2) {
            if ($frame & 4) {   # Extended exit message
                _indent_print_line_info(0, "out ");
                print_trace( $LINEINFO, -1, 1, 1, "$sub$al" );
            }
            else {
                _indent_print_line_info(0, "exited $sub$al\n" );
            }
        }

        if (wantarray) {
            # Print the return info if we need to.
            if ( $doret eq $stack_depth or $frame & 16 ) {

                # Turn off output record separator.
                local $\ = '';
                my $fh = ( $doret eq $stack_depth ? $OUT : $LINEINFO );

                # Indent if we're printing because of $frame tracing.
                if ($frame & 16)
                  {
                      print {$fh} ' ' x $stack_depth;
                  }

                # Print the return value.
                print {$fh} "list context return from $sub:\n";
                dumpit( $fh, \@ret );

                # And don't print it again.
                $doret = -2;
            } ## end if ($doret eq $stack_depth...
            # And we have to return the return value now.
            @ret;
        } ## end if (wantarray)
        # Scalar context.
        else {
            # If we are supposed to show the return value... same as before.
            if ( $doret eq $stack_depth or $frame & 16 and defined wantarray ) {
                local $\ = '';
                my $fh = ( $doret eq $stack_depth ? $OUT : $LINEINFO );
                print $fh ( ' ' x $stack_depth ) if $frame & 16;
                print $fh (
                           defined wantarray
                           ? "scalar context return from $sub: "
                           : "void context return from $sub\n"
                          );
                dumpit( $fh, $ret ) if defined wantarray;
                $doret = -2;
            } ## end if ($doret eq $stack_depth...

            # Return the appropriate scalar value.
            $ret;
        } ## end else [ if (wantarray)
    }
} ## end sub _sub

sub lsub : lvalue {

    # We stack the stack pointer and then increment it to protect us
    # from a situation that might unwind a whole bunch of call frames
    # at once. Localizing the stack pointer means that it will automatically
    # unwind the same amount when multiple stack frames are unwound.
    local $stack_depth = $stack_depth + 1;    # Protect from non-local exits

    # Expand @stack.
    $#stack = $stack_depth;

    # Save current single-step setting.
    $stack[-1] = $single;

    # Turn off all flags except single-stepping.
    # Use local so the single-step value is popped back off the
    # stack for us.
    local $single = $single & 1;

    no strict 'refs';
    {
        # lock ourselves under threads
        lock($DBGR);

        # Whether or not the autoloader was running, a scalar to put the
        # sub's return value in (if needed), and an array to put the sub's
        # return value in (if needed).
        my ( $al, $ret, @ret ) = "";
        if ($sub =~ /^threads::new$/ && $ENV{PERL5DB_THREADED}) {
            print "creating new thread\n";
        }

        # If the last ten characters are C'::AUTOLOAD', note we've traced
        # into AUTOLOAD for $sub.
        if ( length($sub) > 10 && substr( $sub, -10, 10 ) eq '::AUTOLOAD' ) {
            $al = " for $$sub";
        }

        # If we've gotten really deeply recursed, turn on the flag that will
        # make us stop with the 'deep recursion' message.
        $single |= 4 if $stack_depth == $deep;

        # If frame messages are on ...
        _print_frame_message($al);
    }

    # call the original lvalue sub.
    &$sub;
}

# Abstracting common code from multiple places elsewhere:
sub depth_print_lineinfo {
    my $always_print = shift;

    print_lineinfo( @_ ) if ($always_print or $stack_depth < $trace_to_depth);
}

=head1 EXTENDED COMMAND HANDLING AND THE COMMAND API

In Perl 5.8.0, there was a major realignment of the commands and what they did,
Most of the changes were to systematize the command structure and to eliminate
commands that threw away user input without checking.

The following sections describe the code added to make it easy to support
multiple command sets with conflicting command names. This section is a start
at unifying all command processing to make it simpler to develop commands.

Note that all the cmd_[a-zA-Z] subroutines require the command name, a line
number, and C<$dbline> (the current line) as arguments.

Support functions in this section which have multiple modes of failure C<die>
on error; the rest simply return a false value.

The user-interface functions (all of the C<cmd_*> functions) just output
error messages.

=head2 C<%set>

The C<%set> hash defines the mapping from command letter to subroutine
name suffix.

C<%set> is a two-level hash, indexed by set name and then by command name.
Note that trying to set the CommandSet to C<foobar> simply results in the
5.8.0 command set being used, since there's no top-level entry for C<foobar>.

=cut

### The API section

my %set = (    #
    'pre580' => {
        'a' => 'pre580_a',
        'A' => 'pre580_null',
        'b' => 'pre580_b',
        'B' => 'pre580_null',
        'd' => 'pre580_null',
        'D' => 'pre580_D',
        'h' => 'pre580_h',
        'M' => 'pre580_null',
        'O' => 'o',
        'o' => 'pre580_null',
        'v' => 'M',
        'w' => 'v',
        'W' => 'pre580_W',
    },
    'pre590' => {
        '<'  => 'pre590_prepost',
        '<<' => 'pre590_prepost',
        '>'  => 'pre590_prepost',
        '>>' => 'pre590_prepost',
        '{'  => 'pre590_prepost',
        '{{' => 'pre590_prepost',
    },
);

my %breakpoints_data;

sub _has_breakpoint_data_ref {
    my ($filename, $line) = @_;

    return (
        exists( $breakpoints_data{$filename} )
            and
        exists( $breakpoints_data{$filename}{$line} )
    );
}

sub _get_breakpoint_data_ref {
    my ($filename, $line) = @_;

    return ($breakpoints_data{$filename}{$line} ||= +{});
}

sub _delete_breakpoint_data_ref {
    my ($filename, $line) = @_;

    delete($breakpoints_data{$filename}{$line});
    if (! scalar(keys( %{$breakpoints_data{$filename}} )) ) {
        delete($breakpoints_data{$filename});
    }

    return;
}

sub _set_breakpoint_enabled_status {
    my ($filename, $line, $status) = @_;

    _get_breakpoint_data_ref($filename, $line)->{'enabled'} =
        ($status ? 1 : '')
        ;

    return;
}

sub _enable_breakpoint_temp_enabled_status {
    my ($filename, $line) = @_;

    _get_breakpoint_data_ref($filename, $line)->{'temp_enabled'} = 1;

    return;
}

sub _cancel_breakpoint_temp_enabled_status {
    my ($filename, $line) = @_;

    my $ref = _get_breakpoint_data_ref($filename, $line);

    delete ($ref->{'temp_enabled'});

    if (! %$ref) {
        _delete_breakpoint_data_ref($filename, $line);
    }

    return;
}

sub _is_breakpoint_enabled {
    my ($filename, $line) = @_;

    my $data_ref = _get_breakpoint_data_ref($filename, $line);
    return ($data_ref->{'enabled'} || $data_ref->{'temp_enabled'});
}

=head2 C<cmd_wrapper()> (API)

C<cmd_wrapper()> allows the debugger to switch command sets
depending on the value of the C<CommandSet> option.

It tries to look up the command in the C<%set> package-level I<lexical>
(which means external entities can't fiddle with it) and create the name of
the sub to call based on the value found in the hash (if it's there). I<All>
of the commands to be handled in a set have to be added to C<%set>; if they
aren't found, the 5.8.0 equivalent is called (if there is one).

This code uses symbolic references.

=cut

sub cmd_wrapper {
    my $cmd      = shift;
    my $line     = shift;
    my $dblineno = shift;

    # Assemble the command subroutine's name by looking up the
    # command set and command name in %set. If we can't find it,
    # default to the older version of the command.
    my $call = 'cmd_'
      . ( $set{$CommandSet}{$cmd}
          || ( $cmd =~ /\A[<>{]+/o ? 'prepost' : $cmd ) );

    # Call the command subroutine, call it by name.
    return __PACKAGE__->can($call)->( $cmd, $line, $dblineno );
} ## end sub cmd_wrapper

=head3 C<cmd_a> (command)

The C<a> command handles pre-execution actions. These are associated with a
particular line, so they're stored in C<%dbline>. We default to the current
line if none is specified.

=cut

sub cmd_a {
    my $cmd    = shift;
    my $line   = shift || '';    # [.|line] expr
    my $dbline = shift;

    # If it's dot (here), or not all digits,  use the current line.
    $line =~ s/\A\./$dbline/;

    # Should be a line number followed by an expression.
    if ( my ($lineno, $expr) = $line =~ /^\s*(\d*)\s*(\S.+)/ ) {

        if (! length($lineno)) {
            $lineno = $dbline;
        }

        # If we have an expression ...
        if ( length $expr ) {

            # ... but the line isn't breakable, complain.
            if ( $dbline[$lineno] == 0 ) {
                print $OUT
                  "Line $lineno($dbline[$lineno]) does not have an action?\n";
            }
            else {

                # It's executable. Record that the line has an action.
                $had_breakpoints{$filename} |= 2;

                # Remove any action, temp breakpoint, etc.
                $dbline{$lineno} =~ s/\0[^\0]*//;

                # Add the action to the line.
                $dbline{$lineno} .= "\0" . action($expr);

                _set_breakpoint_enabled_status($filename, $lineno, 1);
            }
        } ## end if (length $expr)
    } ## end if ($line =~ /^\s*(\d*)\s*(\S.+)/)
    else {

        # Syntax wrong.
        print $OUT
          "Adding an action requires an optional lineno and an expression\n"
          ;    # hint
    }
} ## end sub cmd_a

=head3 C<cmd_A> (command)

Delete actions. Similar to above, except the delete code is in a separate
subroutine, C<delete_action>.

=cut

sub cmd_A {
    my $cmd    = shift;
    my $line   = shift || '';
    my $dbline = shift;

    # Dot is this line.
    $line =~ s/^\./$dbline/;

    # Call delete_action with a null param to delete them all.
    # The '1' forces the eval to be true. It'll be false only
    # if delete_action blows up for some reason, in which case
    # we print $@ and get out.
    if ( $line eq '*' ) {
        if (! eval { _delete_all_actions(); 1 }) {
            print {$OUT} $@;
            return;
        }
    }

    # There's a real line  number. Pass it to delete_action.
    # Error trapping is as above.
    elsif ( $line =~ /^(\S.*)/ ) {
        if (! eval { delete_action($1); 1 }) {
            print {$OUT} $@;
            return;
        }
    }

    # Swing and a miss. Bad syntax.
    else {
        print $OUT
          "Deleting an action requires a line number, or '*' for all\n" ; # hint
    }
} ## end sub cmd_A

=head3 C<delete_action> (API)

C<delete_action> accepts either a line number or C<undef>. If a line number
is specified, we check for the line being executable (if it's not, it
couldn't have had an  action). If it is, we just take the action off (this
will get any kind of an action, including breakpoints).

=cut

sub _remove_action_from_dbline {
    my $i = shift;

    $dbline{$i} =~ s/\0[^\0]*//;    # \^a
    delete $dbline{$i} if $dbline{$i} eq '';

    return;
}

sub _delete_all_actions {
    print {$OUT} "Deleting all actions...\n";

    for my $file ( keys %had_breakpoints ) {
        local *dbline = $main::{ '_<' . $file };
        $max = $#dbline;
        my $was;
        for my $i (1 .. $max) {
            if ( defined $dbline{$i} ) {
                _remove_action_from_dbline($i);
            }
        }

        unless ( $had_breakpoints{$file} &= ~2 ) {
            delete $had_breakpoints{$file};
        }
    }

    return;
}

sub delete_action {
    my $i = shift;

    if ( defined($i) ) {
        # Can there be one?
        die "Line $i has no action .\n" if $dbline[$i] == 0;

        # Nuke whatever's there.
        _remove_action_from_dbline($i);
    }
    else {
        _delete_all_actions();
    }
}

=head3 C<cmd_b> (command)

Set breakpoints. Since breakpoints can be set in so many places, in so many
ways, conditionally or not, the breakpoint code is kind of complex. Mostly,
we try to parse the command type, and then shuttle it off to an appropriate
subroutine to actually do the work of setting the breakpoint in the right
place.

=cut

sub cmd_b {
    my $cmd    = shift;
    my $line   = shift;    # [.|line] [cond]
    my $dbline = shift;

    my $default_cond = sub {
        my $cond = shift;
        return length($cond) ? $cond : '1';
    };

    # Make . the current line number if it's there..
    $line =~ s/^\.(\s|\z)/$dbline$1/;

    # No line number, no condition. Simple break on current line.
    if ( $line =~ /^\s*$/ ) {
        cmd_b_line( $dbline, 1 );
    }

    # Break on load for a file.
    elsif ( my ($file) = $line =~ /^load\b\s*(.*)/ ) {
        $file =~ s/\s+\z//;
        cmd_b_load($file);
    }

    # b compile|postpone <some sub> [<condition>]
    # The interpreter actually traps this one for us; we just put the
    # necessary condition in the %postponed hash.
    elsif ( my ($action, $subname, $cond)
        = $line =~ /^(postpone|compile)\b\s*([':A-Za-z_][':\w]*)\s*(.*)/ ) {

        # De-Perl4-ify the name - ' separators to ::.
        $subname =~ s/'/::/g;

        # Qualify it into the current package unless it's already qualified.
        $subname = "${package}::" . $subname unless $subname =~ /::/;

        # Add main if it starts with ::.
        $subname = "main" . $subname if substr( $subname, 0, 2 ) eq "::";

        # Save the break type for this sub.
        $postponed{$subname} = (($action eq 'postpone')
            ? ( "break +0 if " . $default_cond->($cond) )
            : "compile");
    } ## end elsif ($line =~ ...
    # b <filename>:<line> [<condition>]
    elsif (my ($filename, $line_num, $cond)
        = $line =~ /\A(\S+[^:]):(\d+)\s*(.*)/ms) {
        cmd_b_filename_line(
            $filename,
            $line_num,
            (length($cond) ? $cond : '1'),
        );
    }
    # b <sub name> [<condition>]
    elsif ( my ($new_subname, $new_cond) =
        $line =~ /^([':A-Za-z_][':\w]*(?:\[.*\])?)\s*(.*)/ ) {

        #
        $subname = $new_subname;
        cmd_b_sub( $subname, $default_cond->($new_cond) );
    }

    # b <line> [<condition>].
    elsif ( my ($line_n, $cond) = $line =~ /^(\d*)\s*(.*)/ ) {

        # Capture the line. If none, it's the current line.
        $line = $line_n || $dbline;

        # Break on line.
        cmd_b_line( $line, $default_cond->($cond) );
    }

    # Line didn't make sense.
    else {
        print "confused by line($line)?\n";
    }

    return;
} ## end sub cmd_b

=head3 C<break_on_load> (API)

We want to break when this file is loaded. Mark this file in the
C<%break_on_load> hash, and note that it has a breakpoint in
C<%had_breakpoints>.

=cut

sub break_on_load {
    my $file = shift;
    $break_on_load{$file} = 1;
    $had_breakpoints{$file} |= 1;
}

=head3 C<report_break_on_load> (API)

Gives us an array of filenames that are set to break on load. Note that
only files with break-on-load are in here, so simply showing the keys
suffices.

=cut

sub report_break_on_load {
    sort keys %break_on_load;
}

=head3 C<cmd_b_load> (command)

We take the file passed in and try to find it in C<%INC> (which maps modules
to files they came from). We mark those files for break-on-load via
C<break_on_load> and then report that it was done.

=cut

sub cmd_b_load {
    my $file = shift;
    my @files;

    # This is a block because that way we can use a redo inside it
    # even without there being any looping structure at all outside it.
    {

        # Save short name and full path if found.
        push @files, $file;
        push @files, $::INC{$file} if $::INC{$file};

        # Tack on .pm and do it again unless there was a '.' in the name
        # already.
        $file .= '.pm', redo unless $file =~ /\./;
    }

    # Do the real work here.
    break_on_load($_) for @files;

    # All the files that have break-on-load breakpoints.
    @files = report_break_on_load;

    # Normalize for the purposes of our printing this.
    local $\ = '';
    local $" = ' ';
    print $OUT "Will stop on load of '@files'.\n";
} ## end sub cmd_b_load

=head3 C<$filename_error> (API package global)

Several of the functions we need to implement in the API need to work both
on the current file and on other files. We don't want to duplicate code, so
C<$filename_error> is used to contain the name of the file that's being
worked on (if it's not the current one).

We can now build functions in pairs: the basic function works on the current
file, and uses C<$filename_error> as part of its error message. Since this is
initialized to C<"">, no filename will appear when we are working on the
current file.

The second function is a wrapper which does the following:

=over 4

=item *

Localizes C<$filename_error> and sets it to the name of the file to be processed.

=item *

Localizes the C<*dbline> glob and reassigns it to point to the file we want to process.

=item *

Calls the first function.

The first function works on the I<current> file (i.e., the one we changed to),
and prints C<$filename_error> in the error message (the name of the other file)
if it needs to. When the functions return, C<*dbline> is restored to point
to the actual current file (the one we're executing in) and
C<$filename_error> is restored to C<"">. This restores everything to
the way it was before the second function was called at all.

See the comments in L<S<C<sub breakable_line>>|/breakable_line(from, to) (API)>
and
L<S<C<sub breakable_line_in_filename>>|/breakable_line_in_filename(file, from, to) (API)>
for more details.

=back

=cut

use vars qw($filename_error);
$filename_error = '';

=head3 breakable_line(from, to) (API)

The subroutine decides whether or not a line in the current file is breakable.
It walks through C<@dbline> within the range of lines specified, looking for
the first line that is breakable.

If C<$to> is greater than C<$from>, the search moves forwards, finding the
first line I<after> C<$to> that's breakable, if there is one.

If C<$from> is greater than C<$to>, the search goes I<backwards>, finding the
first line I<before> C<$to> that's breakable, if there is one.

=cut

sub breakable_line {

    my ( $from, $to ) = @_;

    # $i is the start point. (Where are the FORTRAN programs of yesteryear?)
    my $i = $from;

    # If there are at least 2 arguments, we're trying to search a range.
    if ( @_ >= 2 ) {

        # $delta is positive for a forward search, negative for a backward one.
        my $delta = $from < $to ? +1 : -1;

        # Keep us from running off the ends of the file.
        my $limit = $delta > 0 ? $#dbline : 1;

        # Clever test. If you're a mathematician, it's obvious why this
        # test works. If not:
        # If $delta is positive (going forward), $limit will be $#dbline.
        #    If $to is less than $limit, ($limit - $to) will be positive, times
        #    $delta of 1 (positive), so the result is > 0 and we should use $to
        #    as the stopping point.
        #
        #    If $to is greater than $limit, ($limit - $to) is negative,
        #    times $delta of 1 (positive), so the result is < 0 and we should
        #    use $limit ($#dbline) as the stopping point.
        #
        # If $delta is negative (going backward), $limit will be 1.
        #    If $to is zero, ($limit - $to) will be 1, times $delta of -1
        #    (negative) so the result is > 0, and we use $to as the stopping
        #    point.
        #
        #    If $to is less than zero, ($limit - $to) will be positive,
        #    times $delta of -1 (negative), so the result is not > 0, and
        #    we use $limit (1) as the stopping point.
        #
        #    If $to is 1, ($limit - $to) will zero, times $delta of -1
        #    (negative), still giving zero; the result is not > 0, and
        #    we use $limit (1) as the stopping point.
        #
        #    if $to is >1, ($limit - $to) will be negative, times $delta of -1
        #    (negative), giving a positive (>0) value, so we'll set $limit to
        #    $to.

        $limit = $to if ( $limit - $to ) * $delta > 0;

        # The real search loop.
        # $i starts at $from (the point we want to start searching from).
        # We move through @dbline in the appropriate direction (determined
        # by $delta: either -1 (back) or +1 (ahead).
        # We stay in as long as we haven't hit an executable line
        # ($dbline[$i] == 0 means not executable) and we haven't reached
        # the limit yet (test similar to the above).
        $i += $delta while $dbline[$i] == 0 and ( $limit - $i ) * $delta > 0;

    } ## end if (@_ >= 2)

    # If $i points to a line that is executable, return that.
    return $i unless $dbline[$i] == 0;

    # Format the message and print it: no breakable lines in range.
    my ( $pl, $upto ) = ( '', '' );
    ( $pl, $upto ) = ( 's', "..$to" ) if @_ >= 2 and $from != $to;

    # If there's a filename in filename_error, we'll see it.
    # If not, not.
    die "Line$pl $from$upto$filename_error not breakable\n";
} ## end sub breakable_line

=head3 breakable_line_in_filename(file, from, to) (API)

Like C<breakable_line>, but look in another file.

=cut

sub breakable_line_in_filename {

    # Capture the file name.
    my ($f) = shift;

    # Swap the magic line array over there temporarily.
    local *dbline = $main::{ '_<' . $f };

    # If there's an error, it's in this other file.
    local $filename_error = " of '$f'";

    # Find the breakable line.
    breakable_line(@_);

    # *dbline and $filename_error get restored when this block ends.

} ## end sub breakable_line_in_filename

=head3 break_on_line(lineno, [condition]) (API)

Adds a breakpoint with the specified condition (or 1 if no condition was
specified) to the specified line. Dies if it can't.

=cut

sub break_on_line {
    my $i = shift;
    my $cond = @_ ? shift(@_) : 1;

    my $inii  = $i;
    my $after = '';
    my $pl    = '';

    # Woops, not a breakable line. $filename_error allows us to say
    # if it was in a different file.
    die "Line $i$filename_error not breakable.\n" if $dbline[$i] == 0;

    # Mark this file as having breakpoints in it.
    $had_breakpoints{$filename} |= 1;

    # If there is an action or condition here already ...
    if ( $dbline{$i} ) {

        # ... swap this condition for the existing one.
        $dbline{$i} =~ s/^[^\0]*/$cond/;
    }
    else {

        # Nothing here - just add the condition.
        $dbline{$i} = $cond;

        _set_breakpoint_enabled_status($filename, $i, 1);
    }

    return;
} ## end sub break_on_line

=head3 cmd_b_line(line, [condition]) (command)

Wrapper for C<break_on_line>. Prints the failure message if it
doesn't work.

=cut

sub cmd_b_line {
    if (not eval { break_on_line(@_); 1 }) {
        local $\ = '';
        print $OUT $@ and return;
    }

    return;
} ## end sub cmd_b_line

=head3 cmd_b_filename_line(line, [condition]) (command)

Wrapper for C<break_on_filename_line>. Prints the failure message if it
doesn't work.

=cut

sub cmd_b_filename_line {
    if (not eval { break_on_filename_line(@_); 1 }) {
        local $\ = '';
        print $OUT $@ and return;
    }

    return;
}

=head3 break_on_filename_line(file, line, [condition]) (API)

Switches to the file specified and then calls C<break_on_line> to set
the breakpoint.

=cut

sub break_on_filename_line {
    my $f = shift;
    my $i = shift;
    my $cond = @_ ? shift(@_) : 1;

    # Switch the magical hash temporarily.
    local *dbline = $main::{ '_<' . $f };

    # Localize the variables that break_on_line uses to make its message.
    local $filename_error = " of '$f'";
    local $filename       = $f;

    # Add the breakpoint.
    break_on_line( $i, $cond );

    return;
} ## end sub break_on_filename_line

=head3 break_on_filename_line_range(file, from, to, [condition]) (API)

Switch to another file, search the range of lines specified for an
executable one, and put a breakpoint on the first one you find.

=cut

sub break_on_filename_line_range {
    my $f = shift;
    my $from = shift;
    my $to = shift;
    my $cond = @_ ? shift(@_) : 1;

    # Find a breakable line if there is one.
    my $i = breakable_line_in_filename( $f, $from, $to );

    # Add the breakpoint.
    break_on_filename_line( $f, $i, $cond );

    return;
} ## end sub break_on_filename_line_range

=head3 subroutine_filename_lines(subname, [condition]) (API)

Search for a subroutine within a given file. The condition is ignored.
Uses C<find_sub> to locate the desired subroutine.

=cut

sub subroutine_filename_lines {
    my ( $subname ) = @_;

    # Returned value from find_sub() is fullpathname:startline-endline.
    # The match creates the list (fullpathname, start, end).
    return (find_sub($subname) =~ /^(.*):(\d+)-(\d+)$/);
} ## end sub subroutine_filename_lines

=head3 break_subroutine(subname) (API)

Places a break on the first line possible in the specified subroutine. Uses
C<subroutine_filename_lines> to find the subroutine, and
C<break_on_filename_line_range> to place the break.

=cut

sub break_subroutine {
    my $subname = shift;

    # Get filename, start, and end.
    my ( $file, $s, $e ) = subroutine_filename_lines($subname)
      or die "Subroutine $subname not found.\n";


    # Null condition changes to '1' (always true).
    my $cond = @_ ? shift(@_) : 1;

    # Put a break the first place possible in the range of lines
    # that make up this subroutine.
    break_on_filename_line_range( $file, $s, $e, $cond );

    return;
} ## end sub break_subroutine

=head3 cmd_b_sub(subname, [condition]) (command)

We take the incoming subroutine name and fully-qualify it as best we can.

=over 4

=item 1. If it's already fully-qualified, leave it alone.

=item 2. Try putting it in the current package.

=item 3. If it's not there, try putting it in CORE::GLOBAL if it exists there.

=item 4. If it starts with '::', put it in 'main::'.

=back

After all this cleanup, we call C<break_subroutine> to try to set the
breakpoint.

=cut

sub cmd_b_sub {
    my $subname = shift;
    my $cond = @_ ? shift : 1;

    # If the subname isn't a code reference, qualify it so that
    # break_subroutine() will work right.
    if ( ref($subname) ne 'CODE' ) {

        # Not Perl 4.
        $subname =~ s/'/::/g;
        my $s = $subname;

        # Put it in this package unless it's already qualified.
        if ($subname !~ /::/)
        {
            $subname = $package . '::' . $subname;
        };

        # Requalify it into CORE::GLOBAL if qualifying it into this
        # package resulted in its not being defined, but only do so
        # if it really is in CORE::GLOBAL.
        my $core_name = "CORE::GLOBAL::$s";
        if ((!defined(&$subname))
                and ($s !~ /::/)
                and (defined &{$core_name}))
        {
            $subname = $core_name;
        }

        # Put it in package 'main' if it has a leading ::.
        if ($subname =~ /\A::/)
        {
            $subname = "main" . $subname;
        }
    } ## end if ( ref($subname) ne 'CODE' ) {

    # Try to set the breakpoint.
    if (not eval { break_subroutine( $subname, $cond ); 1 }) {
        local $\ = '';
        print {$OUT} $@;
        return;
    }

    return;
} ## end sub cmd_b_sub

=head3 C<cmd_B> - delete breakpoint(s) (command)

The command mostly parses the command line and tries to turn the argument
into a line spec. If it can't, it uses the current line. It then calls
C<delete_breakpoint> to actually do the work.

If C<*> is  specified, C<cmd_B> calls C<delete_breakpoint> with no arguments,
thereby deleting all the breakpoints.

=cut

sub cmd_B {
    my $cmd = shift;

    # No line spec? Use dbline.
    # If there is one, use it if it's non-zero, or wipe it out if it is.
    my $line   = ( $_[0] =~ /\A\./ ) ? $dbline : (shift || '');
    my $dbline = shift;

    # If the line was dot, make the line the current one.
    $line =~ s/^\./$dbline/;

    # If it's * we're deleting all the breakpoints.
    if ( $line eq '*' ) {
        if (not eval { delete_breakpoint(); 1 }) {
            print {$OUT} $@;
        }
    }

    # If there is a line spec, delete the breakpoint on that line.
    elsif ( $line =~ /\A(\S.*)/ ) {
        if (not eval { delete_breakpoint( $line || $dbline ); 1 }) {
            local $\ = '';
            print {$OUT} $@;
        }
    } ## end elsif ($line =~ /^(\S.*)/)

    # No line spec.
    else {
        print {$OUT}
          "Deleting a breakpoint requires a line number, or '*' for all\n"
          ;    # hint
    }

    return;
} ## end sub cmd_B

=head3 delete_breakpoint([line]) (API)

This actually does the work of deleting either a single breakpoint, or all
of them.

For a single line, we look for it in C<@dbline>. If it's nonbreakable, we
just drop out with a message saying so. If it is, we remove the condition
part of the 'condition\0action' that says there's a breakpoint here. If,
after we've done that, there's nothing left, we delete the corresponding
line in C<%dbline> to signal that no action needs to be taken for this line.

For all breakpoints, we iterate through the keys of C<%had_breakpoints>,
which lists all currently-loaded files which have breakpoints. We then look
at each line in each of these files, temporarily switching the C<%dbline>
and C<@dbline> structures to point to the files in question, and do what
we did in the single line case: delete the condition in C<@dbline>, and
delete the key in C<%dbline> if nothing's left.

We then wholesale delete C<%postponed>, C<%postponed_file>, and
C<%break_on_load>, because these structures contain breakpoints for files
and code that haven't been loaded yet. We can just kill these off because there
are no magical debugger structures associated with them.

=cut

sub _remove_breakpoint_entry {
    my ($fn, $i) = @_;

    delete $dbline{$i};
    _delete_breakpoint_data_ref($fn, $i);

    return;
}

sub _delete_all_breakpoints {
    print {$OUT} "Deleting all breakpoints...\n";

    # %had_breakpoints lists every file that had at least one
    # breakpoint in it.
    for my $fn ( keys %had_breakpoints ) {

        # Switch to the desired file temporarily.
        local *dbline = $main::{ '_<' . $fn };

        $max = $#dbline;

        # For all lines in this file ...
        for my $i (1 .. $max) {

            # If there's a breakpoint or action on this line ...
            if ( defined $dbline{$i} ) {

                # ... remove the breakpoint.
                $dbline{$i} =~ s/\A[^\0]+//;
                if ( $dbline{$i} =~ s/\A\0?\z// ) {
                    # Remove the entry altogether if no action is there.
                    _remove_breakpoint_entry($fn, $i);
                }
            } ## end if (defined $dbline{$i...
        } ## end for $i (1 .. $max)

        # If, after we turn off the "there were breakpoints in this file"
        # bit, the entry in %had_breakpoints for this file is zero,
        # we should remove this file from the hash.
        if ( not $had_breakpoints{$fn} &= (~1) ) {
            delete $had_breakpoints{$fn};
        }
    } ## end for my $fn (keys %had_breakpoints)

    # Kill off all the other breakpoints that are waiting for files that
    # haven't been loaded yet.
    undef %postponed;
    undef %postponed_file;
    undef %break_on_load;

    return;
}

sub _delete_breakpoint_from_line {
    my ($i) = @_;

    # Woops. This line wasn't breakable at all.
    die "Line $i not breakable.\n" if $dbline[$i] == 0;

    # Kill the condition, but leave any action.
    $dbline{$i} =~ s/\A[^\0]*//;

    # Remove the entry entirely if there's no action left.
    if ($dbline{$i} eq '') {
        _remove_breakpoint_entry($filename, $i);
    }

    return;
}

sub delete_breakpoint {
    my $i = shift;

    # If we got a line, delete just that one.
    if ( defined($i) ) {
        _delete_breakpoint_from_line($i);
    }
    # No line; delete them all.
    else {
        _delete_all_breakpoints();
    }

    return;
}

=head3 cmd_stop (command)

This is meant to be part of the new command API, but it isn't called or used
anywhere else in the debugger. XXX It is probably meant for use in development
of new commands.

=cut

sub cmd_stop {    # As on ^C, but not signal-safy.
    $signal = 1;
}

=head3 C<cmd_e> - threads

Display the current thread id:

    e

This could be how (when implemented) to send commands to this thread id (e cmd)
or that thread id (e tid cmd).

=cut

sub cmd_e {
    my $cmd  = shift;
    my $line = shift;
    unless (exists($INC{'threads.pm'})) {
        print "threads not loaded($ENV{PERL5DB_THREADED})
        please run the debugger with PERL5DB_THREADED=1 set in the environment\n";
    } else {
        my $tid = threads->tid;
        print "thread id: $tid\n";
    }
} ## end sub cmd_e

=head3 C<cmd_E> - list of thread ids

Display the list of available thread ids:

    E

This could be used (when implemented) to send commands to all threads (E cmd).

=cut

sub cmd_E {
    my $cmd  = shift;
    my $line = shift;
    unless (exists($INC{'threads.pm'})) {
        print "threads not loaded($ENV{PERL5DB_THREADED})
        please run the debugger with PERL5DB_THREADED=1 set in the environment\n";
    } else {
        my $tid = threads->tid;
        print "thread ids: ".join(', ',
            map { ($tid == $_->tid ? '<'.$_->tid.'>' : $_->tid) } threads->list
        )."\n";
    }
} ## end sub cmd_E

=head3 C<cmd_h> - help command (command)

Does the work of either

=over 4

=item *

Showing all the debugger help

=item *

Showing help for a specific command

=back

=cut

use vars qw($help);
use vars qw($summary);

sub cmd_h {
    my $cmd = shift;

    # If we have no operand, assume null.
    my $line = shift || '';

    # 'h h'. Print the long-format help.
    if ( $line =~ /\Ah\s*\z/ ) {
        print_help($help);
    }

    # 'h <something>'. Search for the command and print only its help.
    elsif ( my ($asked) = $line =~ /\A(\S.*)\z/ ) {

        # support long commands; otherwise bogus errors
        # happen when you ask for h on <CR> for example
        my $qasked = quotemeta($asked);    # for searching; we don't
                                           # want to use it as a pattern.
                                           # XXX: finds CR but not <CR>

        # Search the help string for the command.
        if (
            $help =~ /^                    # Start of a line
                      <?                   # Optional '<'
                      (?:[IB]<)            # Optional markup
                      $qasked              # The requested command
                     /mx
          )
        {

            # It's there; pull it out and print it.
            while (
                $help =~ /^
                              (<?            # Optional '<'
                                 (?:[IB]<)   # Optional markup
                                 $qasked     # The command
                                 ([\s\S]*?)  # Description line(s)
                              \n)            # End of last description line
                              (?!\s)         # Next line not starting with
                                             # whitespace
                             /mgx
              )
            {
                print_help($1);
            }
        }

        # Not found; not a debugger command.
        else {
            print_help("B<$asked> is not a debugger command.\n");
        }
    } ## end elsif ($line =~ /^(\S.*)$/)

    # 'h' - print the summary help.
    else {
        print_help($summary);
    }
} ## end sub cmd_h

=head3 C<cmd_L> - list breakpoints, actions, and watch expressions (command)

To list breakpoints, the command has to look determine where all of them are
first. It starts a C<%had_breakpoints>, which tells us what all files have
breakpoints and/or actions. For each file, we switch the C<*dbline> glob (the
magic source and breakpoint data structures) to the file, and then look
through C<%dbline> for lines with breakpoints and/or actions, listing them
out. We look through C<%postponed> not-yet-compiled subroutines that have
breakpoints, and through C<%postponed_file> for not-yet-C<require>'d files
that have breakpoints.

Watchpoints are simpler: we just list the entries in C<@to_watch>.

=cut

sub _cmd_L_calc_arg {
    # If no argument, list everything. Pre-5.8.0 version always lists
    # everything
    my $arg = shift || 'abw';
    if ($CommandSet ne '580')
    {
        $arg = 'abw';
    }

    return $arg;
}

sub _cmd_L_calc_wanted_flags {
    my $arg = _cmd_L_calc_arg(shift);

    return (map { index($arg, $_) >= 0 ? 1 : 0 } qw(a b w));
}


sub _cmd_L_handle_breakpoints {
    my ($handle_db_line) = @_;

    BREAKPOINTS_SCAN:
    # Look in all the files with breakpoints...
    for my $file ( keys %had_breakpoints ) {

        # Temporary switch to this file.
        local *dbline = $main::{ '_<' . $file };

        # Set up to look through the whole file.
        $max = $#dbline;
        my $was;    # Flag: did we print something
        # in this file?

        # For each line in the file ...
        for my $i (1 .. $max) {

            # We've got something on this line.
            if ( defined $dbline{$i} ) {

                # Print the header if we haven't.
                if (not $was++) {
                    print {$OUT} "$file:\n";
                }

                # Print the line.
                print {$OUT} " $i:\t", $dbline[$i];

                $handle_db_line->($dbline{$i});

                # Quit if the user hit interrupt.
                if ($signal) {
                    last BREAKPOINTS_SCAN;
                }
            } ## end if (defined $dbline{$i...
        } ## end for my $i (1 .. $max)
    } ## end for my $file (keys %had_breakpoints)

    return;
}

sub _cmd_L_handle_postponed_breakpoints {
    my ($handle_db_line) = @_;

    print {$OUT} "Postponed breakpoints in files:\n";

    POSTPONED_SCANS:
    for my $file ( keys %postponed_file ) {
        my $db = $postponed_file{$file};
        print {$OUT} " $file:\n";
        for my $line ( sort { $a <=> $b } keys %$db ) {
            print {$OUT} "  $line:\n";

            $handle_db_line->($db->{$line});

            if ($signal) {
                last POSTPONED_SCANS;
            }
        }
        if ($signal) {
            last POSTPONED_SCANS;
        }
    }

    return;
}


sub cmd_L {
    my $cmd = shift;

    my ($action_wanted, $break_wanted, $watch_wanted) =
        _cmd_L_calc_wanted_flags(shift);

    my $handle_db_line = sub {
        my ($l) = @_;

        my ( $stop, $action ) = split( /\0/, $l );

        if ($stop and $break_wanted) {
            print {$OUT} "    break if (", $stop, ")\n"
        }

        if ($action && $action_wanted) {
            print {$OUT} "    action:  ", $action, "\n"
        }

        return;
    };

    # Breaks and actions are found together, so we look in the same place
    # for both.
    if ( $break_wanted or $action_wanted ) {
        _cmd_L_handle_breakpoints($handle_db_line);
    }

    # Look for breaks in not-yet-compiled subs:
    if ( %postponed and $break_wanted ) {
        print {$OUT} "Postponed breakpoints in subroutines:\n";
        my $subname;
        SUBS_SCAN:
        for $subname ( keys %postponed ) {
            print {$OUT} " $subname\t$postponed{$subname}\n";
            if ($signal) {
                last SUBS_SCAN;
            }
        }
    } ## end if (%postponed and $break_wanted)

    # Find files that have not-yet-loaded breaks:
    my @have = map {    # Combined keys
        keys %{ $postponed_file{$_} }
    } keys %postponed_file;

    # If there are any, list them.
    if ( @have and ( $break_wanted or $action_wanted ) ) {
        _cmd_L_handle_postponed_breakpoints($handle_db_line);
    } ## end if (@have and ($break_wanted...

    if ( %break_on_load and $break_wanted ) {
        print {$OUT} "Breakpoints on load:\n";
        BREAK_ON_LOAD: for my $filename ( keys %break_on_load ) {
            print {$OUT} " $filename\n";
            last BREAK_ON_LOAD if $signal;
        }
    } ## end if (%break_on_load and...

    if ($watch_wanted and ( $trace & 2 )) {
        print {$OUT} "Watch-expressions:\n" if @to_watch;
        TO_WATCH: for my $expr (@to_watch) {
            print {$OUT} " $expr\n";
            last TO_WATCH if $signal;
        }
    }

    return;
} ## end sub cmd_L

=head3 C<cmd_M> - list modules (command)

Just call C<list_modules>.

=cut

sub cmd_M {
    list_modules();

    return;
}

=head3 C<cmd_o> - options (command)

If this is just C<o> by itself, we list the current settings via
C<dump_option>. If there's a nonblank value following it, we pass that on to
C<parse_options> for processing.

=cut

sub cmd_o {
    my $cmd = shift;
    my $opt = shift || '';    # opt[=val]

    # Nonblank. Try to parse and process.
    if ( $opt =~ /^(\S.*)/ ) {
        parse_options($1);
    }

    # Blank. List the current option settings.
    else {
        for (@options) {
            dump_option($_);
        }
    }
} ## end sub cmd_o

=head3 C<cmd_O> - nonexistent in 5.8.x (command)

Advises the user that the O command has been renamed.

=cut

sub cmd_O {
    print $OUT "The old O command is now the o command.\n";             # hint
    print $OUT "Use 'h' to get current command help synopsis or\n";     #
    print $OUT "use 'o CommandSet=pre580' to revert to old usage\n";    #
}

=head3 C<cmd_v> - view window (command)

Uses the C<$preview> variable set in the second C<BEGIN> block (q.v.) to
move back a few lines to list the selected line in context. Uses C<_cmd_l_main>
to do the actual listing after figuring out the range of line to request.

=cut

use vars qw($preview);

sub cmd_v {
    my $cmd  = shift;
    my $line = shift;

    # Extract the line to list around. (Astute readers will have noted that
    # this pattern will match whether or not a numeric line is specified,
    # which means that we'll always enter this loop (though a non-numeric
    # argument results in no action at all)).
    if ( $line =~ /^(\d*)$/ ) {

        # Total number of lines to list (a windowful).
        $incr = $window - 1;

        # Set the start to the argument given (if there was one).
        $start = $1 if $1;

        # Back up by the context amount.
        $start -= $preview;

        # Put together a linespec that _cmd_l_main will like.
        $line = $start . '-' . ( $start + $incr );

        # List the lines.
        _cmd_l_main( $line );
    } ## end if ($line =~ /^(\d*)$/)
} ## end sub cmd_v

=head3 C<cmd_w> - add a watch expression (command)

The 5.8 version of this command adds a watch expression if one is specified;
it does nothing if entered with no operands.

We extract the expression, save it, evaluate it in the user's context, and
save the value. We'll re-evaluate it each time the debugger passes a line,
and will stop (see the code at the top of the command loop) if the value
of any of the expressions changes.

=cut

sub _add_watch_expr {
    my $expr = shift;

    # ... save it.
    push @to_watch, $expr;

    # Parameterize DB::eval and call it to get the expression's value
    # in the user's context. This version can handle expressions which
    # return a list value.
    $evalarg = $expr;
    # The &-call is here to ascertain the mutability of @_.
    my ($val) = join( ' ', &DB::eval);
    $val = ( defined $val ) ? "'$val'" : 'undef';

    # Save the current value of the expression.
    push @old_watch, $val;

    # We are now watching expressions.
    $trace |= 2;

    return;
}

sub cmd_w {
    my $cmd = shift;

    # Null expression if no arguments.
    my $expr = shift || '';

    # If expression is not null ...
    if ( $expr =~ /\A\S/ ) {
        _add_watch_expr($expr);
    } ## end if ($expr =~ /^(\S.*)/)

    # You have to give one to get one.
    else {
        print $OUT "Adding a watch-expression requires an expression\n";  # hint
    }

    return;
}

=head3 C<cmd_W> - delete watch expressions (command)

This command accepts either a watch expression to be removed from the list
of watch expressions, or C<*> to delete them all.

If C<*> is specified, we simply empty the watch expression list and the
watch expression value list. We also turn off the bit that says we've got
watch expressions.

If an expression (or partial expression) is specified, we pattern-match
through the expressions and remove the ones that match. We also discard
the corresponding values. If no watch expressions are left, we turn off
the I<watching expressions> bit.

=cut

sub cmd_W {
    my $cmd  = shift;
    my $expr = shift || '';

    # Delete them all.
    if ( $expr eq '*' ) {

        # Not watching now.
        $trace &= ~2;

        print $OUT "Deleting all watch expressions ...\n";

        # And all gone.
        @to_watch = @old_watch = ();
    }

    # Delete one of them.
    elsif ( $expr =~ /^(\S.*)/ ) {

        # Where we are in the list.
        my $i_cnt = 0;

        # For each expression ...
        foreach (@to_watch) {
            my $val = $to_watch[$i_cnt];

            # Does this one match the command argument?
            if ( $val eq $expr ) {    # =~ m/^\Q$i$/) {
                                      # Yes. Turn it off, and its value too.
                splice( @to_watch,  $i_cnt, 1 );
                splice( @old_watch, $i_cnt, 1 );
            }
            $i_cnt++;
        } ## end foreach (@to_watch)

        # We don't bother to turn watching off because
        #  a) we don't want to stop calling watchfunction() if it exists
        #  b) foreach over a null list doesn't do anything anyway

    } ## end elsif ($expr =~ /^(\S.*)/)

    # No command arguments entered.
    else {
        print $OUT
          "Deleting a watch-expression requires an expression, or '*' for all\n"
          ;    # hint
    }
} ## end sub cmd_W

### END of the API section

=head1 SUPPORT ROUTINES

These are general support routines that are used in a number of places
throughout the debugger.

=head2 save

save() saves the user's versions of globals that would mess us up in C<@saved>,
and installs the versions we like better.

=cut

sub save {

    # Save eval failure, command failure, extended OS error, output field
    # separator, input record separator, output record separator and
    # the warning setting.
    @saved = ( $@, $!, $^E, $,, $/, $\, $^W );

    $,  = "";      # output field separator is null string
    $/  = "\n";    # input record separator is newline
    $\  = "";      # output record separator is null string
    $^W = 0;       # warnings are off
} ## end sub save

=head2 C<print_lineinfo> - show where we are now

print_lineinfo prints whatever it is that it is handed; it prints it to the
C<$LINEINFO> filehandle instead of just printing it to STDOUT. This allows
us to feed line information to a client editor without messing up the
debugger output.

=cut

sub print_lineinfo {

    # Make the terminal sensible if we're not the primary debugger.
    resetterm(1) if $LINEINFO eq $OUT and $term_pid != $$;
    local $\ = '';
    local $, = '';
    # $LINEINFO may be undef if $noTTY is set or some other issue.
    if ($LINEINFO)
    {
        print {$LINEINFO} @_;
    }
} ## end sub print_lineinfo

=head2 C<postponed_sub>

Handles setting postponed breakpoints in subroutines once they're compiled.
For breakpoints, we use C<DB::find_sub> to locate the source file and line
range for the subroutine, then mark the file as having a breakpoint,
temporarily switch the C<*dbline> glob over to the source file, and then
search the given range of lines to find a breakable line. If we find one,
we set the breakpoint on it, deleting the breakpoint from C<%postponed>.

=cut

# The following takes its argument via $evalarg to preserve current @_

sub postponed_sub {

    # Get the subroutine name.
    my $subname = shift;

    # If this is a 'break +<n> if <condition>' ...
    if ( $postponed{$subname} =~ s/^break\s([+-]?\d+)\s+if\s// ) {

        # If there's no offset, use '+0'.
        my $offset = $1 || 0;

        # find_sub's value is 'fullpath-filename:start-stop'. It's
        # possible that the filename might have colons in it too.
        my ( $file, $i ) = ( find_sub($subname) =~ /^(.*):(\d+)-.*$/ );
        if ($i) {

            # We got the start line. Add the offset '+<n>' from
            # $postponed{subname}.
            $i += $offset;

            # Switch to the file this sub is in, temporarily.
            local *dbline = $main::{ '_<' . $file };

            # No warnings, please.
            local $^W = 0;    # != 0 is magical below

            # This file's got a breakpoint in it.
            $had_breakpoints{$file} |= 1;

            # Last line in file.
            $max = $#dbline;

            # Search forward until we hit a breakable line or get to
            # the end of the file.
            ++$i until $dbline[$i] != 0 or $i >= $max;

            # Copy the breakpoint in and delete it from %postponed.
            $dbline{$i} = delete $postponed{$subname};
        } ## end if ($i)

        # find_sub didn't find the sub.
        else {
            local $\ = '';
            print $OUT "Subroutine $subname not found.\n";
        }
        return;
    } ## end if ($postponed{$subname...
    elsif ( $postponed{$subname} eq 'compile' ) { $signal = 1 }

    #print $OUT "In postponed_sub for '$subname'.\n";
} ## end sub postponed_sub

=head2 C<postponed>

Called after each required file is compiled, but before it is executed;
also called if the name of a just-compiled subroutine is a key of
C<%postponed>. Propagates saved breakpoints (from S<C<b compile>>,
S<C<b load>>, etc.) into the just-compiled code.

If this is a C<require>'d file, the incoming parameter is the glob
C<*{"_<$filename"}>, with C<$filename> the name of the C<require>'d file.

If it's a subroutine, the incoming parameter is the subroutine name.

=cut

sub postponed {

    # If there's a break, process it.
    if ($ImmediateStop) {

        # Right, we've stopped. Turn it off.
        $ImmediateStop = 0;

        # Enter the command loop when DB::DB gets called.
        $signal = 1;
    }

    # If this is a subroutine, let postponed_sub() deal with it.
    if (ref(\$_[0]) ne 'GLOB') {
        return postponed_sub(@_);
    }

    # Not a subroutine. Deal with the file.
    local *dbline = shift;
    my $filename = $dbline;
    $filename =~ s/^_<//;
    local $\ = '';
    $signal = 1, print $OUT "'$filename' loaded...\n"
      if $break_on_load{$filename};
    print_lineinfo( ' ' x $stack_depth, "Package $filename.\n" ) if $frame;

    # Do we have any breakpoints to put in this file?
    return unless $postponed_file{$filename};

    # Yes. Mark this file as having breakpoints.
    $had_breakpoints{$filename} |= 1;

    # "Cannot be done: insufficient magic" - we can't just put the
    # breakpoints saved in %postponed_file into %dbline by assigning
    # the whole hash; we have to do it one item at a time for the
    # breakpoints to be set properly.
    #%dbline = %{$postponed_file{$filename}};

    # Set the breakpoints, one at a time.
    my $key;

    for $key ( keys %{ $postponed_file{$filename} } ) {

        # Stash the saved breakpoint into the current file's magic line array.
        $dbline{$key} = ${ $postponed_file{$filename} }{$key};
    }

    # This file's been compiled; discard the stored breakpoints.
    delete $postponed_file{$filename};

} ## end sub postponed

=head2 C<dumpit>

C<dumpit> is the debugger's wrapper around dumpvar.pl.

It gets a filehandle (to which C<dumpvar.pl>'s output will be directed) and
a reference to a variable (the thing to be dumped) as its input.

The incoming filehandle is selected for output (C<dumpvar.pl> is printing to
the currently-selected filehandle, thank you very much). The current
values of the package globals C<$single> and C<$trace> are backed up in
lexicals, and they are turned off (this keeps the debugger from trying
to single-step through C<dumpvar.pl> (I think.)). C<$frame> is localized to
preserve its current value and it is set to zero to prevent entry/exit
messages from printing, and C<$doret> is localized as well and set to -2 to
prevent return values from being shown.

C<dumpit()> then checks to see if it needs to load C<dumpvar.pl> and
tries to load it (note: if you have a C<dumpvar.pl>  ahead of the
installed version in C<@INC>, yours will be used instead. Possible security
problem?).

It then checks to see if the subroutine C<main::dumpValue> is now defined
it should have been defined by C<dumpvar.pl>). If it has, C<dumpit()>
localizes the globals necessary for things to be sane when C<main::dumpValue()>
is called, and picks up the variable to be dumped from the parameter list.

It checks the package global C<%options> to see if there's a C<dumpDepth>
specified. If not, -1 is assumed; if so, the supplied value gets passed on to
C<dumpvar.pl>. This tells C<dumpvar.pl> where to leave off when dumping a
structure: -1 means dump everything.

C<dumpValue()> is then called if possible; if not, C<dumpit()>just prints a
warning.

In either case, C<$single>, C<$trace>, C<$frame>, and C<$doret> are restored
and we then return to the caller.

=cut

sub dumpit {

    # Save the current output filehandle and switch to the one
    # passed in as the first parameter.
    my $savout = select(shift);

    # Save current settings of $single and $trace, and then turn them off.
    my $osingle = $single;
    my $otrace  = $trace;
    $single = $trace = 0;

    # XXX Okay, what do $frame and $doret do, again?
    local $frame = 0;
    local $doret = -2;

    # Load dumpvar.pl unless we've already got the sub we need from it.
    unless ( defined &main::dumpValue ) {
        do 'dumpvar.pl' or die $@;
    }

    # If the load succeeded (or we already had dumpvalue()), go ahead
    # and dump things.
    if ( defined &main::dumpValue ) {
        local $\ = '';
        local $, = '';
        local $" = ' ';
        my $v = shift;
        my $maxdepth = shift || $option{dumpDepth};
        $maxdepth = -1 unless defined $maxdepth;    # -1 means infinite depth
        main::dumpValue( $v, $maxdepth );
    } ## end if (defined &main::dumpValue)

    # Oops, couldn't load dumpvar.pl.
    else {
        local $\ = '';
        print $OUT "dumpvar.pl not available.\n";
    }

    # Reset $single and $trace to their old values.
    $single = $osingle;
    $trace  = $otrace;

    # Restore the old filehandle.
    select($savout);
} ## end sub dumpit

=head2 C<print_trace>

C<print_trace>'s job is to print a stack trace. It does this via the
C<dump_trace> routine, which actually does all the ferreting-out of the
stack trace data. C<print_trace> takes care of formatting it nicely and
printing it to the proper filehandle.

Parameters:

=over 4

=item *

The filehandle to print to.

=item *

How many frames to skip before starting trace.

=item *

How many frames to print.

=item *

A flag: if true, print a I<short> trace without filenames, line numbers, or arguments

=back

The original comment below seems to be noting that the traceback may not be
correct if this routine is called in a tied method.

=cut

# Tied method do not create a context, so may get wrong message:

sub print_trace {
    local $\ = '';
    my $fh = shift;

    # If this is going to a client editor, but we're not the primary
    # debugger, reset it first.
    resetterm(1)
      if $fh        eq $LINEINFO    # client editor
      and $LINEINFO eq $OUT         # normal output
      and $term_pid != $$;          # not the primary

    # Collect the actual trace information to be formatted.
    # This is an array of hashes of subroutine call info.
    my @sub = dump_trace( $_[0] + 1, $_[1] );

    # Grab the "short report" flag from @_.
    my $short = $_[2];              # Print short report, next one for sub name

    # Run through the traceback info, format it, and print it.
    my $s;
    for my $i (0 .. $#sub) {

        # Drop out if the user has lost interest and hit control-C.
        last if $signal;

        # Set the separator so arrays print nice.
        local $" = ', ';

        # Grab and stringify the arguments if they are there.
        my $args =
          defined $sub[$i]{args}
          ? "(@{ $sub[$i]{args} })"
          : '';

        # Shorten them up if $maxtrace says they're too long.
        $args = ( substr $args, 0, $maxtrace - 3 ) . '...'
          if length $args > $maxtrace;

        # Get the file name.
        my $file = $sub[$i]{file};

        # Put in a filename header if short is off.
        $file = $file eq '-e' ? $file : "file '$file'" unless $short;

        # Get the actual sub's name, and shorten to $maxtrace's requirement.
        $s = $sub[$i]{'sub'};
        $s = ( substr $s, 0, $maxtrace - 3 ) . '...' if length $s > $maxtrace;

        # Short report uses trimmed file and sub names.
        if ($short) {
            my $sub = @_ >= 4 ? $_[3] : $s;
            print $fh "$sub[$i]{context}=$sub$args from $file:$sub[$i]{line}\n";
        } ## end if ($short)

        # Non-short report includes full names.
        else {
            print $fh "$sub[$i]{context} = $s$args"
              . " called from $file"
              . " line $sub[$i]{line}\n";
        }
    } ## end for my $i (0 .. $#sub)
} ## end sub print_trace

=head2 dump_trace(skip[,count])

Actually collect the traceback information available via C<caller()>. It does
some filtering and cleanup of the data, but mostly it just collects it to
make C<print_trace()>'s job easier.

C<skip> defines the number of stack frames to be skipped, working backwards
from the most current. C<count> determines the total number of frames to
be returned; all of them (well, the first 10^9) are returned if C<count>
is omitted.

This routine returns a list of hashes, from most-recent to least-recent
stack frame. Each has the following keys and values:

=over 4

=item * C<context> - C<.> (null), C<$> (scalar), or C<@> (array)

=item * C<sub> - subroutine name, or C<eval> information

=item * C<args> - undef, or a reference to an array of arguments

=item * C<file> - the file in which this item was defined (if any)

=item * C<line> - the line on which it was defined

=back

=cut

sub _dump_trace_calc_saved_single_arg
{
    my ($nothard, $arg) = @_;

    my $type;
    if ( not defined $arg ) {    # undefined parameter
        return "undef";
    }

    elsif ( $nothard and tied $arg ) {    # tied parameter
        return "tied";
    }
    elsif ( $nothard and $type = ref $arg ) {    # reference
        return "ref($type)";
    }
    else {                                       # can be stringified
        local $_ =
        "$arg";    # Safe to stringify now - should not call f().

        # Backslash any single-quotes or backslashes.
        s/([\'\\])/\\$1/g;

        # Single-quote it unless it's a number or a colon-separated
        # name.
        s/(.*)/'$1'/s
        unless /^(?: -?[\d.]+ | \*[\w:]* )$/x;

        # Turn high-bit characters into meta-whatever, and controls into like
        # '^D'.
        require 'meta_notation.pm';
        $_ = _meta_notation($_) if /[[:^print:]]/a;

        return $_;
    }
}

sub _dump_trace_calc_save_args {
    my ($nothard) = @_;

    return [
        map { _dump_trace_calc_saved_single_arg($nothard, $_) } @args
    ];
}

sub dump_trace {

    # How many levels to skip.
    my $skip = shift;

    # How many levels to show. (1e9 is a cheap way of saying "all of them";
    # it's unlikely that we'll have more than a billion stack frames. If you
    # do, you've got an awfully big machine...)
    my $count = shift || 1e9;

    # We increment skip because caller(1) is the first level *back* from
    # the current one.  Add $skip to the count of frames so we have a
    # simple stop criterion, counting from $skip to $count+$skip.
    $skip++;
    $count += $skip;

    # These variables are used to capture output from caller();
    my ( $p, $file, $line, $sub, $h, $context );

    my ( $e, $r, @sub, $args );

    # XXX Okay... why'd we do that?
    my $nothard = not $frame & 8;
    local $frame = 0;

    # Do not want to trace this.
    my $otrace = $trace;
    $trace = 0;

    # Start out at the skip count.
    # If we haven't reached the number of frames requested, and caller() is
    # still returning something, stay in the loop. (If we pass the requested
    # number of stack frames, or we run out - caller() returns nothing - we
    # quit.
    # Up the stack frame index to go back one more level each time.
    for (
        my $i = $skip ;
        $i < $count
        and ( $p, $file, $line, $sub, $h, $context, $e, $r ) = caller($i) ;
        $i++
    )
    {
        # if the sub has args ($h true), make an anonymous array of the
        # dumped args.
        my $args = $h ? _dump_trace_calc_save_args($nothard) : undef;

        # If context is true, this is array (@)context.
        # If context is false, this is scalar ($) context.
        # If neither, context isn't defined. (This is apparently a 'can't
        # happen' trap.)
        $context = $context ? '@' : ( defined $context ? "\$" : '.' );

        # remove trailing newline-whitespace-semicolon-end of line sequence
        # from the eval text, if any.
        $e =~ s/\n\s*\;\s*\Z// if $e;

        # Escape backslashed single-quotes again if necessary.
        $e =~ s/([\\\'])/\\$1/g if $e;

        # if the require flag is true, the eval text is from a require.
        if ($r) {
            $sub = "require '$e'";
        }

        # if it's false, the eval text is really from an eval.
        elsif ( defined $r ) {
            $sub = "eval '$e'";
        }

        # If the sub is '(eval)', this is a block eval, meaning we don't
        # know what the eval'ed text actually was.
        elsif ( $sub eq '(eval)' ) {
            $sub = "eval {...}";
        }

        # Stick the collected information into @sub as an anonymous hash.
        push(
            @sub,
            {
                context => $context,
                sub     => $sub,
                args    => $args,
                file    => $file,
                line    => $line
            }
        );

        # Stop processing frames if the user hit control-C.
        last if $signal;
    } ## end for ($i = $skip ; $i < ...

    # Restore the trace value again.
    $trace = $otrace;
    @sub;
} ## end sub dump_trace

=head2 C<action()>

C<action()> takes input provided as the argument to an add-action command,
either pre- or post-, and makes sure it's a complete command. It doesn't do
any fancy parsing; it just keeps reading input until it gets a string
without a trailing backslash.

=cut

sub action {
    my $action = shift;

    while ( $action =~ s/\\$// ) {

        # We have a backslash on the end. Read more.
        $action .= gets();
    } ## end while ($action =~ s/\\$//)

    # Return the assembled action.
    $action;
} ## end sub action

=head2 unbalanced

This routine mostly just packages up a regular expression to be used
to check that the thing it's being matched against has properly-matched
curly braces.

Of note is the definition of the C<$balanced_brace_re> global via C<||=>, which
speeds things up by only creating the qr//'ed expression once; if it's
already defined, we don't try to define it again. A speed hack.

=cut

use vars qw($balanced_brace_re);

sub unbalanced {

    # I hate using globals!
    $balanced_brace_re ||= qr{
        ^ \{
             (?:
                 (?> [^{}] + )              # Non-parens without backtracking
                |
                 (??{ $balanced_brace_re }) # Group with matching parens
              ) *
          \} $
   }x;
    return $_[0] !~ m/$balanced_brace_re/;
} ## end sub unbalanced

=head2 C<gets()>

C<gets()> is a primitive (very primitive) routine to read continuations.
It was devised for reading continuations for actions.
it just reads more input with C<readline()> and returns it.

=cut

sub gets {
    return DB::readline("cont: ");
}

=head2 C<_db_system()> - handle calls to<system()> without messing up the debugger

The C<system()> function assumes that it can just go ahead and use STDIN and
STDOUT, but under the debugger, we want it to use the debugger's input and
outout filehandles.

C<_db_system()> socks away the program's STDIN and STDOUT, and then substitutes
the debugger's IN and OUT filehandles for them. It does the C<system()> call,
and then puts everything back again.

=cut

sub _db_system {

    # We save, change, then restore STDIN and STDOUT to avoid fork() since
    # some non-Unix systems can do system() but have problems with fork().
    open( SAVEIN,  "<&STDIN" )  || _db_warn("Can't save STDIN");
    open( SAVEOUT, ">&STDOUT" ) || _db_warn("Can't save STDOUT");
    open( STDIN,   "<&IN" )     || _db_warn("Can't redirect STDIN");
    open( STDOUT,  ">&OUT" )    || _db_warn("Can't redirect STDOUT");

    # XXX: using csh or tcsh destroys sigint retvals!
    system(@_);
    open( STDIN,  "<&SAVEIN" )  || _db_warn("Can't restore STDIN");
    open( STDOUT, ">&SAVEOUT" ) || _db_warn("Can't restore STDOUT");
    close(SAVEIN);
    close(SAVEOUT);

    # most of the $? crud was coping with broken cshisms
    if ( $? >> 8 ) {
        _db_warn( "(Command exited ", ( $? >> 8 ), ")\n" );
    }
    elsif ($?) {
        _db_warn(
            "(Command died of SIG#",
            ( $? & 127 ),
            ( ( $? & 128 ) ? " -- core dumped" : "" ),
            ")", "\n"
        );
    } ## end elsif ($?)

    return $?;

} ## end sub system

*system = \&_db_system;

=head1 TTY MANAGEMENT

The subs here do some of the terminal management for multiple debuggers.

=head2 setterm

Top-level function called when we want to set up a new terminal for use
by the debugger.

If the C<noTTY> debugger option was set, we'll either use the terminal
supplied (the value of the C<noTTY> option), or we'll use C<Term::Rendezvous>
to find one. If we're a forked debugger, we call C<resetterm> to try to
get a whole new terminal if we can.

In either case, we set up the terminal next. If the C<ReadLine> option was
true, we'll get a C<Term::ReadLine> object for the current terminal and save
the appropriate attributes. We then

=cut

use vars qw($ornaments);
use vars qw($rl_attribs);

sub setterm {

    # Load Term::Readline, but quietly; don't debug it and don't trace it.
    local $frame = 0;
    local $doret = -2;
    require Term::ReadLine;

    # If noTTY is set, but we have a TTY name, go ahead and hook up to it.
    if ($notty) {
        if ($tty) {
            my ( $i, $o ) = split $tty, /,/;
            $o = $i unless defined $o;
            open( IN,  '<', $i ) or die "Cannot open TTY '$i' for read: $!";
            open( OUT, '>', $o ) or die "Cannot open TTY '$o' for write: $!";
            $IN  = \*IN;
            $OUT = \*OUT;
            _autoflush($OUT);
        } ## end if ($tty)

        # We don't have a TTY - try to find one via Term::Rendezvous.
        else {
            require Term::Rendezvous;

            # See if we have anything to pass to Term::Rendezvous.
            # Use $HOME/.perldbtty$$ if not.
            my $rv = $ENV{PERLDB_NOTTY} || "$ENV{HOME}/.perldbtty$$";

            # Rendezvous and get the filehandles.
            my $term_rv = Term::Rendezvous->new( $rv );
            $IN  = $term_rv->IN;
            $OUT = $term_rv->OUT;
        } ## end else [ if ($tty)
    } ## end if ($notty)

    # We're a daughter debugger. Try to fork off another TTY.
    if ( $term_pid eq '-1' ) {    # In a TTY with another debugger
        resetterm(2);
    }

    # If we shouldn't use Term::ReadLine, don't.
    if ( !$rl ) {
        $term = Term::ReadLine::Stub->new( 'perldb', $IN, $OUT );
    }

    # We're using Term::ReadLine. Get all the attributes for this terminal.
    else {
        $term = Term::ReadLine->new( 'perldb', $IN, $OUT );

        $rl_attribs = $term->Attribs;
        $rl_attribs->{basic_word_break_characters} .= '-:+/*,[])}'
          if defined $rl_attribs->{basic_word_break_characters}
          and index( $rl_attribs->{basic_word_break_characters}, ":" ) == -1;
        $rl_attribs->{special_prefixes} = '$@&%';
        $rl_attribs->{completer_word_break_characters} .= '$@&%';
        $rl_attribs->{completion_function} = \&db_complete;
    } ## end else [ if (!$rl)

    # Set up the LINEINFO filehandle.
    $LINEINFO = $OUT     unless defined $LINEINFO;
    $lineinfo = $console unless defined $lineinfo;

    $term->MinLine(2);

    load_hist();

    if ( $term->Features->{setHistory} and "@hist" ne "?" ) {
        $term->SetHistory(@hist);
    }

    # XXX Ornaments are turned on unconditionally, which is not
    # always a good thing.
    ornaments($ornaments) if defined $ornaments;
    $term_pid = $$;
} ## end sub setterm

sub load_hist {
    $histfile //= option_val("HistFile", undef);
    return unless defined $histfile;
    open my $fh, "<", $histfile or return;
    local $/ = "\n";
    @hist = ();
    while (<$fh>) {
        chomp;
        push @hist, $_;
    }
    close $fh;
}

sub save_hist {
    return unless defined $histfile;
    eval { require File::Path } or return;
    eval { require File::Basename } or return;
    File::Path::mkpath(File::Basename::dirname($histfile));
    open my $fh, ">", $histfile or die "Could not open '$histfile': $!";
    $histsize //= option_val("HistSize",100);
    my @copy = grep { $_ ne '?' } @hist;
    my $start = scalar(@copy) > $histsize ? scalar(@copy)-$histsize : 0;
    for ($start .. $#copy) {
        print $fh "$copy[$_]\n";
    }
    close $fh or die "Could not write '$histfile': $!";
}

=head1 GET_FORK_TTY EXAMPLE FUNCTIONS

When the process being debugged forks, or the process invokes a command
via C<system()> which starts a new debugger, we need to be able to get a new
C<IN> and C<OUT> filehandle for the new debugger. Otherwise, the two processes
fight over the terminal, and you can never quite be sure who's going to get the
input you're typing.

C<get_fork_TTY> is a glob-aliased function which calls the real function that
is tasked with doing all the necessary operating system mojo to get a new
TTY (and probably another window) and to direct the new debugger to read and
write there.

The debugger provides C<get_fork_TTY> functions which work for TCP
socket servers, X11, OS/2, and Mac OS X. Other systems are not
supported. You are encouraged to write C<get_fork_TTY> functions which
work for I<your> platform and contribute them.

=head3 C<socket_get_fork_TTY>

=cut

sub connect_remoteport {
    require IO::Socket;

    my $socket = IO::Socket::INET->new(
        Timeout  => '10',
        PeerAddr => $remoteport,
        Proto    => 'tcp',
    );
    if ( ! $socket ) {
        die "Unable to connect to remote host: $remoteport\n";
    }
    return $socket;
}

sub socket_get_fork_TTY {
    $tty = $LINEINFO = $IN = $OUT = connect_remoteport();

    # Do I need to worry about setting $term?

    reset_IN_OUT( $IN, $OUT );
    return '';
}

=head3 C<xterm_get_fork_TTY>

This function provides the C<get_fork_TTY> function for X11. If a
program running under the debugger forks, a new <xterm> window is opened and
the subsidiary debugger is directed there.

The C<open()> call is of particular note here. We have the new C<xterm>
we're spawning route file number 3 to STDOUT, and then execute the C<tty>
command (which prints the device name of the TTY we'll want to use for input
and output to STDOUT, then C<sleep> for a very long time, routing this output
to file number 3. This way we can simply read from the <XT> filehandle (which
is STDOUT from the I<commands> we ran) to get the TTY we want to use.

Only works if C<xterm> is in your path and C<$ENV{DISPLAY}>, etc. are
properly set up.

=cut

sub xterm_get_fork_TTY {
    ( my $name = $0 ) =~ s,^.*[/\\],,s;
    open XT,
qq[3>&1 x-terminal-emulator -T "Daughter Perl debugger $pids $name" -e sh -c 'tty 1>&3;\
 sleep 10000000' |];

    # Get the output from 'tty' and clean it up a little.
    my $tty = <XT>;
    chomp $tty;

    $pidprompt = '';    # Shown anyway in titlebar

    # We need $term defined or we can not switch to the newly created xterm
    if ($tty ne '' && !defined $term) {
        require Term::ReadLine;
        if ( !$rl ) {
            $term = Term::ReadLine::Stub->new( 'perldb', $IN, $OUT );
        }
        else {
            $term = Term::ReadLine->new( 'perldb', $IN, $OUT );
        }
    }
    # There's our new TTY.
    return $tty;
} ## end sub xterm_get_fork_TTY

=head3 C<os2_get_fork_TTY>

XXX It behooves an OS/2 expert to write the necessary documentation for this!

=cut

# This example function resets $IN, $OUT itself
my $c_pipe = 0;
sub os2_get_fork_TTY { # A simplification of the following (and works without):
    local $\  = '';
    ( my $name = $0 ) =~ s,^.*[/\\],,s;
    my %opt = ( title => "Daughter Perl debugger $pids $name",
        ($rl ? (read_by_key => 1) : ()) );
    require OS2::Process;
    my ($in, $out, $pid) = eval { OS2::Process::io_term(related => 0, %opt) }
      or return;
    $pidprompt = '';    # Shown anyway in titlebar
    reset_IN_OUT($in, $out);
    $tty = '*reset*';
    return '';          # Indicate that reset_IN_OUT is called
} ## end sub os2_get_fork_TTY

=head3 C<macosx_get_fork_TTY>

The Mac OS X version uses AppleScript to tell Terminal.app to create
a new window.

=cut

# Notes about Terminal.app's AppleScript support,
# (aka things that might break in future OS versions).
#
# The "do script" command doesn't return a reference to the new window
# it creates, but since it appears frontmost and windows are enumerated
# front to back, we can use "first window" === "window 1".
#
# Since "do script" is implemented by supplying the argument (plus a
# return character) as terminal input, there's a potential race condition
# where the debugger could beat the shell to reading the command.
# To prevent this, we wait for the screen to clear before proceeding.
#
# 10.3 and 10.4:
# There's no direct accessor for the tty device name, so we fiddle
# with the window title options until it says what we want.
#
# 10.5:
# There _is_ a direct accessor for the tty device name, _and_ there's
# a new possible component of the window title (the name of the settings
# set).  A separate version is needed.

my @script_versions=

    ([237, <<'__LEOPARD__'],
tell application "Terminal"
    do script "clear;exec sleep 100000"
    tell first tab of first window
        copy tty to thetty
        set custom title to "forked perl debugger"
        set title displays custom title to true
        repeat while (length of first paragraph of (get contents)) > 0
            delay 0.1
        end repeat
    end tell
end tell
thetty
__LEOPARD__

     [100, <<'__JAGUAR_TIGER__'],
tell application "Terminal"
    do script "clear;exec sleep 100000"
    tell first window
        set title displays shell path to false
        set title displays window size to false
        set title displays file name to false
        set title displays device name to true
        set title displays custom title to true
        set custom title to ""
        copy "/dev/" & name to thetty
        set custom title to "forked perl debugger"
        repeat while (length of first paragraph of (get contents)) > 0
            delay 0.1
        end repeat
    end tell
end tell
thetty
__JAGUAR_TIGER__

);

sub macosx_get_fork_TTY
{
    my($version,$script,$pipe,$tty);

    return unless $version=$ENV{TERM_PROGRAM_VERSION};
    foreach my $entry (@script_versions) {
        if ($version>=$entry->[0]) {
            $script=$entry->[1];
            last;
        }
    }
    return unless defined($script);
    return unless open($pipe,'-|','/usr/bin/osascript','-e',$script);
    $tty=readline($pipe);
    close($pipe);
    return unless defined($tty) && $tty =~ m(^/dev/);
    chomp $tty;
    return $tty;
}

=head3 C<tmux_get_fork_TTY>

Creates a split window for subprocesses when a process running under the
perl debugger in Tmux forks.

=cut

sub tmux_get_fork_TTY {
    return unless $ENV{TMUX};

    my $pipe;

    my $status = open $pipe, '-|', 'tmux', 'split-window',
        '-P', '-F', '#{pane_tty}', 'sleep 100000';

    if ( !$status ) {
        return;
    }

    my $tty = <$pipe>;
    close $pipe;

    if ( $tty ) {
        chomp $tty;

        if ( !defined $term ) {
            require Term::ReadLine;
            if ( !$rl ) {
                $term = Term::ReadLine::Stub->new( 'perldb', $IN, $OUT );
            }
            else {
                $term = Term::ReadLine->new( 'perldb', $IN, $OUT );
            }
        }
    }

    return $tty;
}

=head2 C<create_IN_OUT($flags)>

Create a new pair of filehandles, pointing to a new TTY. If impossible,
try to diagnose why.

Flags are:

=over 4

=item * 1 - Don't know how to create a new TTY.

=item * 2 - Debugger has forked, but we can't get a new TTY.

=item * 4 - standard debugger startup is happening.

=back

=cut

use vars qw($fork_TTY);

sub create_IN_OUT {    # Create a window with IN/OUT handles redirected there

    # If we know how to get a new TTY, do it! $in will have
    # the TTY name if get_fork_TTY works.
    my $in = get_fork_TTY(@_) if defined &get_fork_TTY;

    # It used to be that
    $in = $fork_TTY if defined $fork_TTY;    # Backward compatibility

    if ( not defined $in ) {
        my $why = shift;

        # We don't know how.
        print_help(<<EOP) if $why == 1;
I<#########> Forked, but do not know how to create a new B<TTY>. I<#########>
EOP

        # Forked debugger.
        print_help(<<EOP) if $why == 2;
I<#########> Daughter session, do not know how to change a B<TTY>. I<#########>
  This may be an asynchronous session, so the parent debugger may be active.
EOP

        # Note that both debuggers are fighting over the same input.
        print_help(<<EOP) if $why != 4;
  Since two debuggers fight for the same TTY, input is severely entangled.

EOP
        print_help(<<EOP);
  I know how to switch the output to a different window in xterms, OS/2
  consoles, and Mac OS X Terminal.app only.  For a manual switch, put the name
  of the created I<TTY> in B<\$DB::fork_TTY>, or define a function
  B<DB::get_fork_TTY()> returning this.

  On I<UNIX>-like systems one can get the name of a I<TTY> for the given window
  by typing B<tty>, and disconnect the I<shell> from I<TTY> by S<B<sleep 1000000>>.

EOP
    } ## end if (not defined $in)
    elsif ( $in ne '' ) {
        TTY($in);
    }
    else {
        $console = '';    # Indicate no need to open-from-the-console
    }
    undef $fork_TTY;
} ## end sub create_IN_OUT

=head2 C<resetterm>

Handles rejiggering the prompt when we've forked off a new debugger.

If the new debugger happened because of a C<system()> that invoked a
program under the debugger, the arrow between the old pid and the new
in the prompt has I<two> dashes instead of one.

We take the current list of pids and add this one to the end. If there
isn't any list yet, we make one up out of the initial pid associated with
the terminal and our new pid, sticking an arrow (either one-dashed or
two dashed) in between them.

If C<CreateTTY> is off, or C<resetterm> was called with no arguments,
we don't try to create a new IN and OUT filehandle. Otherwise, we go ahead
and try to do that.

=cut

sub resetterm {    # We forked, so we need a different TTY

    # Needs to be passed to create_IN_OUT() as well.
    my $in = shift;

    # resetterm(2): got in here because of a system() starting a debugger.
    # resetterm(1): just forked.
    my $systemed = $in > 1 ? '-' : '';

    # If there's already a list of pids, add this to the end.
    if ($pids) {
        $pids =~ s/\]/$systemed->$$]/;
    }

    # No pid list. Time to make one.
    else {
        $pids = "[$term_pid->$$]";
    }

    # The prompt we're going to be using for this debugger.
    $pidprompt = $pids;

    # We now 0wnz this terminal.
    $term_pid = $$;

    # Just return if we're not supposed to try to create a new TTY.
    return unless $CreateTTY & $in;

    # Try to create a new IN/OUT pair.
    create_IN_OUT($in);
} ## end sub resetterm

=head2 C<readline>

First, we handle stuff in the typeahead buffer. If there is any, we shift off
the next line, print a message saying we got it, add it to the terminal
history (if possible), and return it.

If there's nothing in the typeahead buffer, check the command filehandle stack.
If there are any filehandles there, read from the last one, and return the line
if we got one. If not, we pop the filehandle off and close it, and try the
next one up the stack.

If we've emptied the filehandle stack, we check to see if we've got a socket
open, and we read that and return it if we do. If we don't, we just call the
core C<readline()> and return its value.

=cut

sub readline {

    # Localize to prevent it from being smashed in the program being debugged.
    local $.;

    # If there are stacked filehandles to read from ...
    # (Handle it before the typeahead, because we may call source/etc. from
    # the typeahead.)
    while (@cmdfhs) {

        # Read from the last one in the stack.
        my $line = CORE::readline( $cmdfhs[-1] );

        # If we got a line ...
        defined $line
          ? ( print $OUT ">> $line" and return $line )    # Echo and return
          : close pop @cmdfhs;                            # Pop and close
    } ## end while (@cmdfhs)

    # Pull a line out of the typeahead if there's stuff there.
    if (@typeahead) {

        # How many lines left.
        my $left = @typeahead;

        # Get the next line.
        my $got = shift @typeahead;

        # Print a message saying we got input from the typeahead.
        local $\ = '';
        print $OUT "auto(-$left)", shift, $got, "\n";

        # Add it to the terminal history (if possible).
        $term->AddHistory($got)
          if length($got) >= option_val("HistItemMinLength", 2)
          and defined $term->Features->{addHistory};
        return $got;
    } ## end if (@typeahead)

    # We really need to read some input. Turn off entry/exit trace and
    # return value printing.
    local $frame = 0;
    local $doret = -2;

    # Nothing on the filehandle stack. Socket?
    if ( ref $OUT and UNIVERSAL::isa( $OUT, 'IO::Socket::INET' ) ) {

        # Send anything we have to send.
        $OUT->write( join( '', @_ ) );

        # Receive anything there is to receive.
        my $stuff = '';
        my $buf;
        my $first_time = 1;

        while ($first_time or (length($buf) && ($stuff .= $buf) !~ /\n/))
        {
            $first_time = 0;
            $IN->recv( $buf = '', 2048 );   # XXX "what's wrong with sysread?"
                                            # XXX Don't know. You tell me.
        }

        # What we got.
        return $stuff;
    } ## end if (ref $OUT and UNIVERSAL::isa...

    # No socket. Just read from the terminal.
    else {
        return $term->readline(@_);
    }
} ## end sub readline

=head1 OPTIONS SUPPORT ROUTINES

These routines handle listing and setting option values.

=head2 C<dump_option> - list the current value of an option setting

This routine uses C<option_val> to look up the value for an option.
It cleans up escaped single-quotes and then displays the option and
its value.

=cut

sub dump_option {
    my ( $opt, $val ) = @_;
    $val = option_val( $opt, 'N/A' );
    $val =~ s/([\\\'])/\\$1/g;
    printf $OUT "%20s = '%s'\n", $opt, $val;
} ## end sub dump_option

sub options2remember {
    foreach my $k (@RememberOnROptions) {
        $option{$k} = option_val( $k, 'N/A' );
    }
    return %option;
}

=head2 C<option_val> - find the current value of an option

This can't just be a simple hash lookup because of the indirect way that
the option values are stored. Some are retrieved by calling a subroutine,
some are just variables.

You must supply a default value to be used in case the option isn't set.

=cut

sub option_val {
    my ( $opt, $default ) = @_;
    my $val;

    # Does this option exist, and is it a variable?
    # If so, retrieve the value via the value in %optionVars.
    if (    defined $optionVars{$opt}
        and defined ${ $optionVars{$opt} } )
    {
        $val = ${ $optionVars{$opt} };
    }

    # Does this option exist, and it's a subroutine?
    # If so, call the subroutine via the ref in %optionAction
    # and capture the value.
    elsif ( defined $optionAction{$opt}
        and defined &{ $optionAction{$opt} } )
    {
        $val = &{ $optionAction{$opt} }();
    }

    # If there's an action or variable for the supplied option,
    # but no value was set, use the default.
    elsif (defined $optionAction{$opt} and not defined $option{$opt}
        or defined $optionVars{$opt} and not defined ${ $optionVars{$opt} } )
    {
        $val = $default;
    }

    # Otherwise, do the simple hash lookup.
    else {
        $val = $option{$opt};
    }

    # If the value isn't defined, use the default.
    # Then return whatever the value is.
    $val = $default unless defined $val;
    $val;
} ## end sub option_val

=head2 C<parse_options>

Handles the parsing and execution of option setting/displaying commands.

An option entered by itself is assumed to be I<set me to 1> (the default value)
if the option is a boolean one. If not, the user is prompted to enter a valid
value or to query the current value (via C<option? >).

If C<option=value> is entered, we try to extract a quoted string from the
value (if it is quoted). If it's not, we just use the whole value as-is.

We load any modules required to service this option, and then we set it: if
it just gets stuck in a variable, we do that; if there's a subroutine to
handle setting the option, we call that.

Finally, if we're running in interactive mode, we display the effect of the
user's command back to the terminal, skipping this if we're setting things
during initialization.

=cut

sub parse_options {
    my ($s) = @_;
    local $\ = '';

    my $option;

    # These options need a value. Don't allow them to be clobbered by accident.
    my %opt_needs_val = map { ( $_ => 1 ) } qw{
      dumpDepth arrayDepth hashDepth LineInfo maxTraceLen ornaments windowSize
      pager quote ReadLine recallCommand RemotePort ShellBang TTY CommandSet
    };

    while (length($s)) {
        my $val_defaulted;

        # Clean off excess leading whitespace.
        $s =~ s/^\s+// && next;

        # Options are always all word characters, followed by a non-word
        # separator.
        if ($s !~ s/^(\w+)(\W?)//) {
            print {$OUT} "Invalid option '$s'\n";
            last;
        }
        my ( $opt, $sep ) = ( $1, $2 );

        # Make sure that such an option exists.
        my $matches = ( grep { /^\Q$opt/ && ( $option = $_ ) } @options )
          || ( grep { /^\Q$opt/i && ( $option = $_ ) } @options );

        unless ($matches) {
            print {$OUT} "Unknown option '$opt'\n";
            next;
        }
        if ($matches > 1) {
            print {$OUT} "Ambiguous option '$opt'\n";
            next;
        }
        my $val;

        # '?' as separator means query, but must have whitespace after it.
        if ( "?" eq $sep ) {
            if ($s =~ /\A\S/) {
                print {$OUT} "Option query '$opt?' followed by non-space '$s'\n" ;

                last;
            }

            #&dump_option($opt);
        } ## end if ("?" eq $sep)

        # Separator is whitespace (or just a carriage return).
        # They're going for a default, which we assume is 1.
        elsif ( $sep !~ /\S/ ) {
            $val_defaulted = 1;
            $val           = "1";   #  this is an evil default; make 'em set it!
        }

        # Separator is =. Trying to set a value.
        elsif ( $sep eq "=" ) {

            # If quoted, extract a quoted string.
            if ($s =~ s/ (["']) ( (?: \\. | (?! \1 ) [^\\] )* ) \1 //x) {
                my $quote = $1;
                ( $val = $2 ) =~ s/\\([$quote\\])/$1/g;
            }

            # Not quoted. Use the whole thing. Warn about 'option='.
            else {
                $s =~ s/^(\S*)//;
                $val = $1;
                print OUT qq(Option better cleared using $opt=""\n)
                  unless length $val;
            } ## end else [ if (s/ (["']) ( (?: \\. | (?! \1 ) [^\\] )* ) \1 //x)

        } ## end elsif ($sep eq "=")

        # "Quoted" with [], <>, or {}.
        else {    #{ to "let some poor schmuck bounce on the % key in B<vi>."
            my ($end) =
              "\\" . substr( ")]>}$sep", index( "([<{", $sep ), 1 );    #}
            $s =~ s/^(([^\\$end]|\\[\\$end])*)$end($|\s+)//
              or print( $OUT "Unclosed option value '$opt$sep$_'\n" ), last;
            ( $val = $1 ) =~ s/\\([\\$end])/$1/g;
        } ## end else [ if ("?" eq $sep)

        # Exclude non-booleans from getting set to 1 by default.
        if ( $opt_needs_val{$option} && $val_defaulted ) {
            my $cmd = ( $CommandSet eq '580' ) ? 'o' : 'O';
            print {$OUT}
"Option '$opt' is non-boolean.  Use '$cmd $option=VAL' to set, '$cmd $option?' to query\n";
            next;
        } ## end if ($opt_needs_val{$option...

        # Save the option value.
        $option{$option} = $val if defined $val;

        # Load any module that this option requires.
        if ( defined($optionRequire{$option}) && defined($val) ) {
            eval qq{
            local \$frame = 0;
            local \$doret = -2;
            require '$optionRequire{$option}';
            1;
            } || die $@   # XXX: shouldn't happen
        }

        # Set it.
        # Stick it in the proper variable if it goes in a variable.
        if (defined($optionVars{$option}) && defined($val)) {
            ${ $optionVars{$option} } = $val;
        }

        # Call the appropriate sub if it gets set via sub.
        if (defined($optionAction{$option})
          && defined (&{ $optionAction{$option} })
          && defined ($val))
        {
          &{ $optionAction{$option} }($val);
        }

        # Not initialization - echo the value we set it to.
        dump_option($option) if ($OUT ne \*STDERR);
    } ## end while (length)
} ## end sub parse_options

=head1 RESTART SUPPORT

These routines are used to store (and restore) lists of items in environment
variables during a restart.

=head2 set_list

Set_list packages up items to be stored in a set of environment variables
(VAR_n, containing the number of items, and VAR_0, VAR_1, etc., containing
the values). Values outside the standard ASCII charset are stored by encoding
them as hexadecimal values.

=cut

sub set_list {
    my ( $stem, @list ) = @_;
    my $val;

    # VAR_n: how many we have. Scalar assignment gets the number of items.
    $ENV{"${stem}_n"} = @list;

    # Grab each item in the list, escape the backslashes, encode the non-ASCII
    # as hex, and then save in the appropriate VAR_0, VAR_1, etc.
    for my $i ( 0 .. $#list ) {
        $val = $list[$i];
        $val =~ s/\\/\\\\/g;
        $val =~ s/ ( (?[ [\000-\xFF] & [:^print:] ]) ) /
                                                "\\0x" . unpack('H2',$1)/xaeg;
        $ENV{"${stem}_$i"} = $val;
    } ## end for $i (0 .. $#list)
} ## end sub set_list

=head2 get_list

Reverse the set_list operation: grab VAR_n to see how many we should be getting
back, and then pull VAR_0, VAR_1. etc. back out.

=cut

sub get_list {
    my $stem = shift;
    my @list;
    my $n = delete $ENV{"${stem}_n"};
    my $val;
    for my $i ( 0 .. $n - 1 ) {
        $val = delete $ENV{"${stem}_$i"};
        $val =~ s/\\((\\)|0x(..))/ $2 ? $2 : pack('H2', $3) /ge;
        push @list, $val;
    }
    @list;
} ## end sub get_list

=head1 MISCELLANEOUS SIGNAL AND I/O MANAGEMENT

=head2 catch()

The C<catch()> subroutine is the essence of fast and low-impact. We simply
set an already-existing global scalar variable to a constant value. This
avoids allocating any memory possibly in the middle of something that will
get all confused if we do, particularly under I<unsafe signals>.

=cut

sub catch {
    $signal = 1;
    return;    # Put nothing on the stack - malloc/free land!
}

=head2 C<warn()>

C<warn> emits a warning, by joining together its arguments and printing
them, with couple of fillips.

If the composited message I<doesn't> end with a newline, we automatically
add C<$!> and a newline to the end of the message. The subroutine expects $OUT
to be set to the filehandle to be used to output warnings; it makes no
assumptions about what filehandles are available.

=cut

sub _db_warn {
    my ($msg) = join( "", @_ );
    $msg .= ": $!\n" unless $msg =~ /\n$/;
    local $\ = '';
    print $OUT $msg;
} ## end sub warn

*warn = \&_db_warn;

=head1 INITIALIZATION TTY SUPPORT

=head2 C<reset_IN_OUT>

This routine handles restoring the debugger's input and output filehandles
after we've tried and failed to move them elsewhere.  In addition, it assigns
the debugger's output filehandle to $LINEINFO if it was already open there.

=cut

sub reset_IN_OUT {
    my $switch_li = $LINEINFO eq $OUT;

    # If there's a term and it's able to get a new tty, try to get one.
    if ( $term and $term->Features->{newTTY} ) {
        ( $IN, $OUT ) = ( shift, shift );
        $term->newTTY( $IN, $OUT );
    }

    # This term can't get a new tty now. Better luck later.
    elsif ($term) {
        _db_warn("Too late to set IN/OUT filehandles, enabled on next 'R'!\n");
    }

    # Set the filehndles up as they were.
    else {
        ( $IN, $OUT ) = ( shift, shift );
    }

    # Unbuffer the output filehandle.
    _autoflush($OUT);

    # Point LINEINFO to the same output filehandle if it was there before.
    $LINEINFO = $OUT if $switch_li;
} ## end sub reset_IN_OUT

=head1 OPTION SUPPORT ROUTINES

The following routines are used to process some of the more complicated
debugger options.

=head2 C<TTY>

Sets the input and output filehandles to the specified files or pipes.
If the terminal supports switching, we go ahead and do it. If not, and
there's already a terminal in place, we save the information to take effect
on restart.

If there's no terminal yet (for instance, during debugger initialization),
we go ahead and set C<$console> and C<$tty> to the file indicated.

=cut

sub TTY {

    if ( @_ and $term and $term->Features->{newTTY} ) {

        # This terminal supports switching to a new TTY.
        # Can be a list of two files, or on string containing both names,
        # comma-separated.
        # XXX Should this perhaps be an assignment from @_?
        my ( $in, $out ) = shift;
        if ( $in =~ /,/ ) {

            # Split list apart if supplied.
            ( $in, $out ) = split /,/, $in, 2;
        }
        else {

            # Use the same file for both input and output.
            $out = $in;
        }

        # Open file onto the debugger's filehandles, if you can.
        open IN,  '<', $in or die "cannot open '$in' for read: $!";
        open OUT, '>', $out or die "cannot open '$out' for write: $!";

        # Swap to the new filehandles.
        reset_IN_OUT( \*IN, \*OUT );

        # Save the setting for later.
        return $tty = $in;
    } ## end if (@_ and $term and $term...

    # Terminal doesn't support new TTY, or doesn't support readline.
    # Can't do it now, try restarting.
    if ($term and @_) {
        _db_warn("Too late to set TTY, enabled on next 'R'!\n");
    }

    # Useful if done through PERLDB_OPTS:
    $console = $tty = shift if @_;

    # Return whatever the TTY is.
    $tty or $console;
} ## end sub TTY

=head2 C<noTTY>

Sets the C<$notty> global, controlling whether or not the debugger tries to
get a terminal to read from. If called after a terminal is already in place,
we save the value to use it if we're restarted.

=cut

sub noTTY {
    if ($term) {
        _db_warn("Too late to set noTTY, enabled on next 'R'!\n") if @_;
    }
    $notty = shift if @_;
    $notty;
} ## end sub noTTY

=head2 C<ReadLine>

Sets the C<$rl> option variable. If 0, we use C<Term::ReadLine::Stub>
(essentially, no C<readline> processing on this I<terminal>). Otherwise, we
use C<Term::ReadLine>. Can't be changed after a terminal's in place; we save
the value in case a restart is done so we can change it then.

=cut

sub ReadLine {
    if ($term) {
        _db_warn("Too late to set ReadLine, enabled on next 'R'!\n") if @_;
    }
    $rl = shift if @_;
    $rl;
} ## end sub ReadLine

=head2 C<RemotePort>

Sets the port that the debugger will try to connect to when starting up.
If the terminal's already been set up, we can't do it, but we remember the
setting in case the user does a restart.

=cut

sub RemotePort {
    if ($term) {
        _db_warn("Too late to set RemotePort, enabled on next 'R'!\n") if @_;
    }
    $remoteport = shift if @_;
    $remoteport;
} ## end sub RemotePort

=head2 C<tkRunning>

Checks with the terminal to see if C<Tk> is running, and returns true or
false. Returns false if the current terminal doesn't support C<readline>.

=cut

sub tkRunning {
    if ( ${ $term->Features }{tkRunning} ) {
        return $term->tkRunning(@_);
    }
    else {
        local $\ = '';
        print $OUT "tkRunning not supported by current ReadLine package.\n";
        0;
    }
} ## end sub tkRunning

=head2 C<NonStop>

Sets nonstop mode. If a terminal's already been set up, it's too late; the
debugger remembers the setting in case you restart, though.

=cut

sub NonStop {
    if ($term) {
        _db_warn("Too late to set up NonStop mode, enabled on next 'R'!\n")
          if @_;
    }
    $runnonstop = shift if @_;
    $runnonstop;
} ## end sub NonStop

sub DollarCaretP {
    if ($term) {
        _db_warn("Some flag changes could not take effect until next 'R'!\n")
          if @_;
    }
    $^P = parse_DollarCaretP_flags(shift) if @_;
    expand_DollarCaretP_flags($^P);
}

=head2 C<pager>

Set up the C<$pager> variable. Adds a pipe to the front unless there's one
there already.

=cut

sub pager {
    if (@_) {
        $pager = shift;
        $pager = "|" . $pager unless $pager =~ /^(\+?\>|\|)/;
    }
    $pager;
} ## end sub pager

=head2 C<shellBang>

Sets the shell escape command, and generates a printable copy to be used
in the help.

=cut

sub shellBang {

    # If we got an argument, meta-quote it, and add '\b' if it
    # ends in a word character.
    if (@_) {
        $sh = quotemeta shift;
        $sh .= "\\b" if $sh =~ /\w$/;
    }

    # Generate the printable version for the help:
    $psh = $sh;    # copy it
    $psh =~ s/\\b$//;        # Take off trailing \b if any
    $psh =~ s/\\(.)/$1/g;    # De-escape
    $psh;                    # return the printable version
} ## end sub shellBang

=head2 C<ornaments>

If the terminal has its own ornaments, fetch them. Otherwise accept whatever
was passed as the argument. (This means you can't override the terminal's
ornaments.)

=cut

sub ornaments {
    if ( defined $term ) {

        # We don't want to show warning backtraces, but we do want die() ones.
        local $warnLevel = 0;
        local $dieLevel = 1;

        # No ornaments if the terminal doesn't support them.
        if (not $term->Features->{ornaments}) {
            return '';
        }

        return (eval { $term->ornaments(@_) } || '');
    }

    # Use what was passed in if we can't determine it ourselves.
    else {
        $ornaments = shift;

        return $ornaments;
    }

} ## end sub ornaments

=head2 C<recallCommand>

Sets the recall command, and builds a printable version which will appear in
the help text.

=cut

sub recallCommand {

    # If there is input, metaquote it. Add '\b' if it ends with a word
    # character.
    if (@_) {
        $rc = quotemeta shift;
        $rc .= "\\b" if $rc =~ /\w$/;
    }

    # Build it into a printable version.
    $prc = $rc;              # Copy it
    $prc =~ s/\\b$//;        # Remove trailing \b
    $prc =~ s/\\(.)/$1/g;    # Remove escapes
    return $prc;             # Return the printable version
} ## end sub recallCommand

=head2 C<LineInfo> - where the line number information goes

Called with no arguments, returns the file or pipe that line info should go to.

Called with an argument (a file or a pipe), it opens that onto the
C<LINEINFO> filehandle, unbuffers the filehandle, and then returns the
file or pipe again to the caller.

=cut

sub LineInfo {
    if (@_) {
        $lineinfo = shift;

        #  If this is a valid "thing to be opened for output", tack a
        # '>' onto the front.
        my $stream = ( $lineinfo =~ /^(\+?\>|\|)/ ) ? $lineinfo : ">$lineinfo";

        # If this is a pipe, the stream points to a client editor.
        $client_editor = ( $stream =~ /^\|/ );

        my $new_lineinfo_fh;
        # Open it up and unbuffer it.
        open ($new_lineinfo_fh , $stream )
            or _db_warn("Cannot open '$stream' for write");
        $LINEINFO = $new_lineinfo_fh;
        _autoflush($LINEINFO);
    }

    return $lineinfo;
} ## end sub LineInfo

=head1 COMMAND SUPPORT ROUTINES

These subroutines provide functionality for various commands.

=head2 C<list_modules>

For the C<M> command: list modules loaded and their versions.
Essentially just runs through the keys in %INC, picks each package's
C<$VERSION> variable, gets the file name, and formats the information
for output.

=cut

sub list_modules {    # versions
    my %version;
    my $file;

    # keys are the "as-loaded" name, values are the fully-qualified path
    # to the file itself.
    for ( keys %INC ) {
        $file = $_;                                # get the module name
        s,\.p[lm]$,,i;                             # remove '.pl' or '.pm'
        s,/,::,g;                                  # change '/' to '::'
        s/^perl5db$/DB/;                           # Special case: debugger
                                                   # moves to package DB
        s/^Term::ReadLine::readline$/readline/;    # simplify readline

        # If the package has a $VERSION package global (as all good packages
        # should!) decode it and save as partial message.
        my $pkg_version = do { no strict 'refs'; ${ $_ . '::VERSION' } };
        if ( defined $pkg_version ) {
            $version{$file} = "$pkg_version from ";
        }

        # Finish up the message with the file the package came from.
        $version{$file} .= $INC{$file};
    } ## end for (keys %INC)

    # Hey, dumpit() formats a hash nicely, so why not use it?
    dumpit( $OUT, \%version );
} ## end sub list_modules

=head2 C<sethelp()>

Sets up the monster string used to format and print the help.

=head3 HELP MESSAGE FORMAT

The help message is a peculiar format unto itself; it mixes C<pod> I<ornaments>
(C<< B<> >> C<< I<> >>) with tabs to come up with a format that's fairly
easy to parse and portable, but which still allows the help to be a little
nicer than just plain text.

Essentially, you define the command name (usually marked up with C<< B<> >>
and C<< I<> >>), followed by a tab, and then the descriptive text, ending in a
newline. The descriptive text can also be marked up in the same way. If you
need to continue the descriptive text to another line, start that line with
just tabs and then enter the marked-up text.

If you are modifying the help text, I<be careful>. The help-string parser is
not very sophisticated, and if you don't follow these rules it will mangle the
help beyond hope until you fix the string.

=cut

use vars qw($pre580_help);
use vars qw($pre580_summary);

sub sethelp {

    # XXX: make sure there are tabs between the command and explanation,
    #      or print_help will screw up your formatting if you have
    #      eeevil ornaments enabled.  This is an insane mess.

    $help = "
Help is currently only available for the new 5.8 command set.
No help is available for the old command set.
We assume you know what you're doing if you switch to it.

B<T>        Stack trace.
B<s> [I<expr>]    Single step [in I<expr>].
B<n> [I<expr>]    Next, steps over subroutine calls [in I<expr>].
<B<CR>>        Repeat last B<n> or B<s> command.
B<r>        Return from current subroutine.
B<c> [I<line>|I<sub>]    Continue; optionally inserts a one-time-only breakpoint
        at the specified position.
B<l> I<min>B<+>I<incr>    List I<incr>+1 lines starting at I<min>.
B<l> I<min>B<->I<max>    List lines I<min> through I<max>.
B<l> I<line>        List single I<line>.
B<l> I<subname>    List first window of lines from subroutine.
B<l> I<\$var>        List first window of lines from subroutine referenced by I<\$var>.
B<l>        List next window of lines.
B<->        List previous window of lines.
B<v> [I<line>]    View window around I<line>.
B<.>        Return to the executed line.
B<f> I<filename>    Switch to viewing I<filename>. File must be already loaded.
        I<filename> may be either the full name of the file, or a regular
        expression matching the full file name:
        B<f> I</home/me/foo.pl> and B<f> I<oo\\.> may access the same file.
        Evals (with saved bodies) are considered to be filenames:
        B<f> I<(eval 7)> and B<f> I<eval 7\\b> access the body of the 7th eval
        (in the order of execution).
B</>I<pattern>B</>    Search forwards for I<pattern>; final B</> is optional.
B<?>I<pattern>B<?>    Search backwards for I<pattern>; final B<?> is optional.
B<L> [I<a|b|w>]        List actions and or breakpoints and or watch-expressions.
B<S> [[B<!>]I<pattern>]    List subroutine names [not] matching I<pattern>.
B<t> [I<n>]       Toggle trace mode (to max I<n> levels below current stack depth).
B<t> [I<n>] I<expr>        Trace through execution of I<expr>.
B<b>        Sets breakpoint on current line)
B<b> [I<line>] [I<condition>]
        Set breakpoint; I<line> defaults to the current execution line;
        I<condition> breaks if it evaluates to true, defaults to '1'.
B<b> I<subname> [I<condition>]
        Set breakpoint at first line of subroutine.
B<b> I<\$var>        Set breakpoint at first line of subroutine referenced by I<\$var>.
B<b> B<load> I<filename> Set breakpoint on 'require'ing the given file.
B<b> B<postpone> I<subname> [I<condition>]
        Set breakpoint at first line of subroutine after
        it is compiled.
B<b> B<compile> I<subname>
        Stop after the subroutine is compiled.
B<B> [I<line>]    Delete the breakpoint for I<line>.
B<B> I<*>             Delete all breakpoints.
B<a> [I<line>] I<command>
        Set an action to be done before the I<line> is executed;
        I<line> defaults to the current execution line.
        Sequence is: check for breakpoint/watchpoint, print line
        if necessary, do action, prompt user if necessary,
        execute line.
B<a>        Does nothing
B<A> [I<line>]    Delete the action for I<line>.
B<A> I<*>             Delete all actions.
B<w> I<expr>        Add a global watch-expression.
B<w>             Does nothing
B<W> I<expr>        Delete a global watch-expression.
B<W> I<*>             Delete all watch-expressions.
B<V> [I<pkg> [I<vars>]]    List some (default all) variables in package (default current).
        Use B<~>I<pattern> and B<!>I<pattern> for positive and negative regexps.
B<X> [I<vars>]    Same as \"B<V> I<currentpackage> [I<vars>]\".
B<x> I<expr>        Evals expression in list context, dumps the result.
B<m> I<expr>        Evals expression in list context, prints methods callable
        on the first element of the result.
B<m> I<class>        Prints methods callable via the given class.
B<M>        Show versions of loaded modules.
B<i> I<class>       Prints nested parents of given class.
B<e>         Display current thread id.
B<E>         Display all thread ids the current one will be identified: <n>.
B<y> [I<n> [I<Vars>]]   List lexicals in higher scope <n>.  Vars same as B<V>.

B<<> ?            List Perl commands to run before each prompt.
B<<> I<expr>        Define Perl command to run before each prompt.
B<<<> I<expr>        Add to the list of Perl commands to run before each prompt.
B<< *>                Delete the list of perl commands to run before each prompt.
B<>> ?            List Perl commands to run after each prompt.
B<>> I<expr>        Define Perl command to run after each prompt.
B<>>B<>> I<expr>        Add to the list of Perl commands to run after each prompt.
B<>>B< *>        Delete the list of Perl commands to run after each prompt.
B<{> I<db_command>    Define debugger command to run before each prompt.
B<{> ?            List debugger commands to run before each prompt.
B<{{> I<db_command>    Add to the list of debugger commands to run before each prompt.
B<{ *>             Delete the list of debugger commands to run before each prompt.
B<$prc> I<number>    Redo a previous command (default previous command).
B<$prc> I<-number>    Redo number'th-to-last command.
B<$prc> I<pattern>    Redo last command that started with I<pattern>.
        See 'B<O> I<recallCommand>' too.
B<$psh$psh> I<cmd>      Run cmd in a subprocess (reads from DB::IN, writes to DB::OUT)"
      . (
        $rc eq $sh
        ? ""
        : "
B<$psh> [I<cmd>] Run I<cmd> in subshell (forces \"\$SHELL -c 'cmd'\")."
      ) . "
        See 'B<O> I<shellBang>' too.
B<source> I<file>     Execute I<file> containing debugger commands (may nest).
B<save> I<file>       Save current debugger session (actual history) to I<file>.
B<rerun>           Rerun session to current position.
B<rerun> I<n>         Rerun session to numbered command.
B<rerun> I<-n>        Rerun session to number'th-to-last command.
B<H> I<-number>    Display last number commands (default all).
B<H> I<*>          Delete complete history.
B<p> I<expr>        Same as \"I<print {DB::OUT} expr>\" in current package.
B<|>I<dbcmd>        Run debugger command, piping DB::OUT to current pager.
B<||>I<dbcmd>        Same as B<|>I<dbcmd> but DB::OUT is temporarily select()ed as well.
B<\=> [I<alias> I<value>]    Define a command alias, or list current aliases.
I<command>        Execute as a perl statement in current package.
B<R>        Pure-man-restart of debugger, some of debugger state
        and command-line options may be lost.
        Currently the following settings are preserved:
        history, breakpoints and actions, debugger B<O>ptions
        and the following command-line options: I<-w>, I<-I>, I<-e>.

B<o> [I<opt>] ...    Set boolean option to true
B<o> [I<opt>B<?>]    Query options
B<o> [I<opt>B<=>I<val>] [I<opt>=B<\">I<val>B<\">] ...
        Set options.  Use quotes if spaces in value.
    I<recallCommand>, I<ShellBang>    chars used to recall command or spawn shell;
    I<pager>            program for output of \"|cmd\";
    I<tkRunning>            run Tk while prompting (with ReadLine);
    I<signalLevel> I<warnLevel> I<dieLevel>    level of verbosity;
    I<inhibit_exit>        Allows stepping off the end of the script.
    I<ImmediateStop>        Debugger should stop as early as possible.
    I<RemotePort>            Remote hostname:port for remote debugging
  The following options affect what happens with B<V>, B<X>, and B<x> commands:
    I<arrayDepth>, I<hashDepth>     print only first N elements ('' for all);
    I<compactDump>, I<veryCompact>     change style of array and hash dump;
    I<globPrint>             whether to print contents of globs;
    I<DumpDBFiles>         dump arrays holding debugged files;
    I<DumpPackages>         dump symbol tables of packages;
    I<DumpReused>             dump contents of \"reused\" addresses;
    I<quote>, I<HighBit>, I<undefPrint>     change style of string dump;
    I<bareStringify>         Do not print the overload-stringified value;
  Other options include:
    I<PrintRet>        affects printing of return value after B<r> command,
    I<frame>        affects printing messages on subroutine entry/exit.
    I<AutoTrace>    affects printing messages on possible breaking points.
    I<maxTraceLen>    gives max length of evals/args listed in stack trace.
    I<ornaments>     affects screen appearance of the command line.
    I<CreateTTY>     bits control attempts to create a new TTY on events:
            1: on fork()    2: debugger is started inside debugger
            4: on startup
    During startup options are initialized from \$ENV{PERLDB_OPTS}.
    You can put additional initialization options I<TTY>, I<noTTY>,
    I<ReadLine>, I<NonStop>, and I<RemotePort> there (or use
    B<R> after you set them).

B<q> or B<^D>        Quit. Set B<\$DB::finished = 0> to debug global destruction.
B<h>        Summary of debugger commands.
B<h> [I<db_command>]    Get help [on a specific debugger command], enter B<|h> to page.
B<h h>        Long help for debugger commands
B<$doccmd> I<manpage>    Runs the external doc viewer B<$doccmd> command on the
        named Perl I<manpage>, or on B<$doccmd> itself if omitted.
        Set B<\$DB::doccmd> to change viewer.

Type '|h h' for a paged display if this was too hard to read.

";    # Fix balance of vi % matching: }}}}

    #  note: tabs in the following section are not-so-helpful
    $summary = <<"END_SUM";
I<List/search source lines:>               I<Control script execution:>
  B<l> [I<ln>|I<sub>]  List source code            B<T>           Stack trace
  B<-> or B<.>      List previous/current line  B<s> [I<expr>]    Single step [in expr]
  B<v> [I<line>]    View around line            B<n> [I<expr>]    Next, steps over subs
  B<f> I<filename>  View source in file         <B<CR>/B<Enter>>  Repeat last B<n> or B<s>
  B</>I<pattern>B</> B<?>I<patt>B<?>   Search forw/backw    B<r>           Return from subroutine
  B<M>           Show module versions        B<c> [I<ln>|I<sub>]  Continue until position
I<Debugger controls:>                        B<L>           List break/watch/actions
  B<o> [...]     Set debugger options        B<t> [I<n>] [I<expr>] Toggle trace [max depth] ][trace expr]
  B<<>[B<<>]|B<{>[B<{>]|B<>>[B<>>] [I<cmd>] Do pre/post-prompt B<b> [I<ln>|I<event>|I<sub>] [I<cnd>] Set breakpoint
  B<$prc> [I<N>|I<pat>]   Redo a previous command     B<B> I<ln|*>      Delete a/all breakpoints
  B<H> [I<-num>]    Display last num commands   B<a> [I<ln>] I<cmd>  Do cmd before line
  B<=> [I<a> I<val>]   Define/list an alias        B<A> I<ln|*>      Delete a/all actions
  B<h> [I<db_cmd>]  Get help on command         B<w> I<expr>      Add a watch expression
  B<h h>         Complete help page          B<W> I<expr|*>    Delete a/all watch exprs
  B<|>[B<|>]I<db_cmd>  Send output to pager        B<$psh>\[B<$psh>\] I<syscmd> Run cmd in a subprocess
  B<q> or B<^D>     Quit                        B<R>           Attempt a restart
I<Data Examination:>     B<expr>     Execute perl code, also see: B<s>,B<n>,B<t> I<expr>
  B<x>|B<m> I<expr>       Evals expr in list context, dumps the result or lists methods.
  B<p> I<expr>         Print expression (uses script's current package).
  B<S> [[B<!>]I<pat>]     List subroutine names [not] matching pattern
  B<V> [I<Pk> [I<Vars>]]  List Variables in Package.  Vars can be ~pattern or !pattern.
  B<X> [I<Vars>]       Same as \"B<V> I<current_package> [I<Vars>]\".  B<i> I<class> inheritance tree.
  B<y> [I<n> [I<Vars>]]   List lexicals in higher scope <n>.  Vars same as B<V>.
  B<e>     Display thread id     B<E> Display all thread ids.
For more help, type B<h> I<cmd_letter>, or run B<$doccmd perldebug> for all docs.
END_SUM

    # ')}}; # Fix balance of vi % matching

    # and this is really numb...
    $pre580_help = "
B<T>        Stack trace.
B<s> [I<expr>]    Single step [in I<expr>].
B<n> [I<expr>]    Next, steps over subroutine calls [in I<expr>].
B<CR>>        Repeat last B<n> or B<s> command.
B<r>        Return from current subroutine.
B<c> [I<line>|I<sub>]    Continue; optionally inserts a one-time-only breakpoint
        at the specified position.
B<l> I<min>B<+>I<incr>    List I<incr>+1 lines starting at I<min>.
B<l> I<min>B<->I<max>    List lines I<min> through I<max>.
B<l> I<line>        List single I<line>.
B<l> I<subname>    List first window of lines from subroutine.
B<l> I<\$var>        List first window of lines from subroutine referenced by I<\$var>.
B<l>        List next window of lines.
B<->        List previous window of lines.
B<w> [I<line>]    List window around I<line>.
B<.>        Return to the executed line.
B<f> I<filename>    Switch to viewing I<filename>. File must be already loaded.
        I<filename> may be either the full name of the file, or a regular
        expression matching the full file name:
        B<f> I</home/me/foo.pl> and B<f> I<oo\\.> may access the same file.
        Evals (with saved bodies) are considered to be filenames:
        B<f> I<(eval 7)> and B<f> I<eval 7\\b> access the body of the 7th eval
        (in the order of execution).
B</>I<pattern>B</>    Search forwards for I<pattern>; final B</> is optional.
B<?>I<pattern>B<?>    Search backwards for I<pattern>; final B<?> is optional.
B<L>        List all breakpoints and actions.
B<S> [[B<!>]I<pattern>]    List subroutine names [not] matching I<pattern>.
B<t> [I<n>]       Toggle trace mode (to max I<n> levels below current stack depth) .
B<t> [I<n>] I<expr>        Trace through execution of I<expr>.
B<b> [I<line>] [I<condition>]
        Set breakpoint; I<line> defaults to the current execution line;
        I<condition> breaks if it evaluates to true, defaults to '1'.
B<b> I<subname> [I<condition>]
        Set breakpoint at first line of subroutine.
B<b> I<\$var>        Set breakpoint at first line of subroutine referenced by I<\$var>.
B<b> B<load> I<filename> Set breakpoint on 'require'ing the given file.
B<b> B<postpone> I<subname> [I<condition>]
        Set breakpoint at first line of subroutine after
        it is compiled.
B<b> B<compile> I<subname>
        Stop after the subroutine is compiled.
B<d> [I<line>]    Delete the breakpoint for I<line>.
B<D>        Delete all breakpoints.
B<a> [I<line>] I<command>
        Set an action to be done before the I<line> is executed;
        I<line> defaults to the current execution line.
        Sequence is: check for breakpoint/watchpoint, print line
        if necessary, do action, prompt user if necessary,
        execute line.
B<a> [I<line>]    Delete the action for I<line>.
B<A>        Delete all actions.
B<W> I<expr>        Add a global watch-expression.
B<W>        Delete all watch-expressions.
B<V> [I<pkg> [I<vars>]]    List some (default all) variables in package (default current).
        Use B<~>I<pattern> and B<!>I<pattern> for positive and negative regexps.
B<X> [I<vars>]    Same as \"B<V> I<currentpackage> [I<vars>]\".
B<x> I<expr>        Evals expression in list context, dumps the result.
B<m> I<expr>        Evals expression in list context, prints methods callable
        on the first element of the result.
B<m> I<class>        Prints methods callable via the given class.

B<<> ?            List Perl commands to run before each prompt.
B<<> I<expr>        Define Perl command to run before each prompt.
B<<<> I<expr>        Add to the list of Perl commands to run before each prompt.
B<>> ?            List Perl commands to run after each prompt.
B<>> I<expr>        Define Perl command to run after each prompt.
B<>>B<>> I<expr>        Add to the list of Perl commands to run after each prompt.
B<{> I<db_command>    Define debugger command to run before each prompt.
B<{> ?            List debugger commands to run before each prompt.
B<{{> I<db_command>    Add to the list of debugger commands to run before each prompt.
B<$prc> I<number>    Redo a previous command (default previous command).
B<$prc> I<-number>    Redo number'th-to-last command.
B<$prc> I<pattern>    Redo last command that started with I<pattern>.
        See 'B<O> I<recallCommand>' too.
B<$psh$psh> I<cmd>      Run cmd in a subprocess (reads from DB::IN, writes to DB::OUT)"
      . (
        $rc eq $sh
        ? ""
        : "
B<$psh> [I<cmd>]     Run I<cmd> in subshell (forces \"\$SHELL -c 'cmd'\")."
      ) . "
        See 'B<O> I<shellBang>' too.
B<source> I<file>        Execute I<file> containing debugger commands (may nest).
B<H> I<-number>    Display last number commands (default all).
B<p> I<expr>        Same as \"I<print {DB::OUT} expr>\" in current package.
B<|>I<dbcmd>        Run debugger command, piping DB::OUT to current pager.
B<||>I<dbcmd>        Same as B<|>I<dbcmd> but DB::OUT is temporarilly select()ed as well.
B<\=> [I<alias> I<value>]    Define a command alias, or list current aliases.
I<command>        Execute as a perl statement in current package.
B<v>        Show versions of loaded modules.
B<R>        Pure-man-restart of debugger, some of debugger state
        and command-line options may be lost.
        Currently the following settings are preserved:
        history, breakpoints and actions, debugger B<O>ptions
        and the following command-line options: I<-w>, I<-I>, I<-e>.

B<O> [I<opt>] ...    Set boolean option to true
B<O> [I<opt>B<?>]    Query options
B<O> [I<opt>B<=>I<val>] [I<opt>=B<\">I<val>B<\">] ...
        Set options.  Use quotes if spaces in value.
    I<recallCommand>, I<ShellBang>    chars used to recall command or spawn shell;
    I<pager>            program for output of \"|cmd\";
    I<tkRunning>            run Tk while prompting (with ReadLine);
    I<signalLevel> I<warnLevel> I<dieLevel>    level of verbosity;
    I<inhibit_exit>        Allows stepping off the end of the script.
    I<ImmediateStop>        Debugger should stop as early as possible.
    I<RemotePort>            Remote hostname:port for remote debugging
  The following options affect what happens with B<V>, B<X>, and B<x> commands:
    I<arrayDepth>, I<hashDepth>     print only first N elements ('' for all);
    I<compactDump>, I<veryCompact>     change style of array and hash dump;
    I<globPrint>             whether to print contents of globs;
    I<DumpDBFiles>         dump arrays holding debugged files;
    I<DumpPackages>         dump symbol tables of packages;
    I<DumpReused>             dump contents of \"reused\" addresses;
    I<quote>, I<HighBit>, I<undefPrint>     change style of string dump;
    I<bareStringify>         Do not print the overload-stringified value;
  Other options include:
    I<PrintRet>        affects printing of return value after B<r> command,
    I<frame>        affects printing messages on subroutine entry/exit.
    I<AutoTrace>    affects printing messages on possible breaking points.
    I<maxTraceLen>    gives max length of evals/args listed in stack trace.
    I<ornaments>     affects screen appearance of the command line.
    I<CreateTTY>     bits control attempts to create a new TTY on events:
            1: on fork()    2: debugger is started inside debugger
            4: on startup
    During startup options are initialized from \$ENV{PERLDB_OPTS}.
    You can put additional initialization options I<TTY>, I<noTTY>,
    I<ReadLine>, I<NonStop>, and I<RemotePort> there (or use
    B<R> after you set them).

B<q> or B<^D>        Quit. Set B<\$DB::finished = 0> to debug global destruction.
B<h> [I<db_command>]    Get help [on a specific debugger command], enter B<|h> to page.
B<h h>        Summary of debugger commands.
B<$doccmd> I<manpage>    Runs the external doc viewer B<$doccmd> command on the
        named Perl I<manpage>, or on B<$doccmd> itself if omitted.
        Set B<\$DB::doccmd> to change viewer.

Type '|h' for a paged display if this was too hard to read.

";    # Fix balance of vi % matching: }}}}

    #  note: tabs in the following section are not-so-helpful
    $pre580_summary = <<"END_SUM";
I<List/search source lines:>               I<Control script execution:>
  B<l> [I<ln>|I<sub>]  List source code            B<T>           Stack trace
  B<-> or B<.>      List previous/current line  B<s> [I<expr>]    Single step [in expr]
  B<w> [I<line>]    List around line            B<n> [I<expr>]    Next, steps over subs
  B<f> I<filename>  View source in file         <B<CR>/B<Enter>>  Repeat last B<n> or B<s>
  B</>I<pattern>B</> B<?>I<patt>B<?>   Search forw/backw    B<r>           Return from subroutine
  B<v>           Show versions of modules    B<c> [I<ln>|I<sub>]  Continue until position
I<Debugger controls:>                        B<L>           List break/watch/actions
  B<O> [...]     Set debugger options        B<t> [I<expr>]    Toggle trace [trace expr]
  B<<>[B<<>]|B<{>[B<{>]|B<>>[B<>>] [I<cmd>] Do pre/post-prompt B<b> [I<ln>|I<event>|I<sub>] [I<cnd>] Set breakpoint
  B<$prc> [I<N>|I<pat>]   Redo a previous command     B<d> [I<ln>] or B<D> Delete a/all breakpoints
  B<H> [I<-num>]    Display last num commands   B<a> [I<ln>] I<cmd>  Do cmd before line
  B<=> [I<a> I<val>]   Define/list an alias        B<W> I<expr>      Add a watch expression
  B<h> [I<db_cmd>]  Get help on command         B<A> or B<W>      Delete all actions/watch
  B<|>[B<|>]I<db_cmd>  Send output to pager        B<$psh>\[B<$psh>\] I<syscmd> Run cmd in a subprocess
  B<q> or B<^D>     Quit                        B<R>           Attempt a restart
I<Data Examination:>     B<expr>     Execute perl code, also see: B<s>,B<n>,B<t> I<expr>
  B<x>|B<m> I<expr>       Evals expr in list context, dumps the result or lists methods.
  B<p> I<expr>         Print expression (uses script's current package).
  B<S> [[B<!>]I<pat>]     List subroutine names [not] matching pattern
  B<V> [I<Pk> [I<Vars>]]  List Variables in Package.  Vars can be ~pattern or !pattern.
  B<X> [I<Vars>]       Same as \"B<V> I<current_package> [I<Vars>]\".
  B<y> [I<n> [I<Vars>]]   List lexicals in higher scope <n>.  Vars same as B<V>.
For more help, type B<h> I<cmd_letter>, or run B<$doccmd perldebug> for all docs.
END_SUM

    # ')}}; # Fix balance of vi % matching

} ## end sub sethelp

=head2 C<print_help()>

Most of what C<print_help> does is just text formatting. It finds the
C<B> and C<I> ornaments, cleans them off, and substitutes the proper
terminal control characters to simulate them (courtesy of
C<Term::ReadLine::TermCap>).

=cut

sub print_help {
    my $help_str = shift;

    # Restore proper alignment destroyed by eeevil I<> and B<>
    # ornaments: A pox on both their houses!
    #
    # A help command will have everything up to and including
    # the first tab sequence padded into a field 16 (or if indented 20)
    # wide.  If it's wider than that, an extra space will be added.
    $help_str =~ s{
        ^                       # only matters at start of line
          ( \ {4} | \t )*       # some subcommands are indented
          ( < ?                 # so <CR> works
            [BI] < [^\t\n] + )  # find an eeevil ornament
          ( \t+ )               # original separation, discarded
          ( .* )                # this will now start (no earlier) than
                                # column 16
    } {
        my($leadwhite, $command, $midwhite, $text) = ($1, $2, $3, $4);
        my $clean = $command;
        $clean =~ s/[BI]<([^>]*)>/$1/g;

        # replace with this whole string:
        ($leadwhite ? " " x 4 : "")
      . $command
      . ((" " x (16 + ($leadwhite ? 4 : 0) - length($clean))) || " ")
      . $text;

    }mgex;

    $help_str =~ s{                          # handle bold ornaments
       B < ( [^>] + | > ) >
    } {
          $Term::ReadLine::TermCap::rl_term_set[2]
        . $1
        . $Term::ReadLine::TermCap::rl_term_set[3]
    }gex;

    $help_str =~ s{                         # handle italic ornaments
       I < ( [^>] + | > ) >
    } {
          $Term::ReadLine::TermCap::rl_term_set[0]
        . $1
        . $Term::ReadLine::TermCap::rl_term_set[1]
    }gex;

    local $\ = '';
    print {$OUT} $help_str;

    return;
} ## end sub print_help

=head2 C<fix_less>

This routine does a lot of gyrations to be sure that the pager is C<less>.
It checks for C<less> masquerading as C<more> and records the result in
C<$fixed_less> so we don't have to go through doing the stats again.

=cut

use vars qw($fixed_less);

sub _calc_is_less {
    if ($pager =~ /\bless\b/)
    {
        return 1;
    }
    elsif ($pager =~ /\bmore\b/)
    {
        # Nope, set to more. See what's out there.
        my @st_more = stat('/usr/bin/more');
        my @st_less = stat('/usr/bin/less');

        # is it really less, pretending to be more?
        return (
            @st_more
            && @st_less
            && $st_more[0] == $st_less[0]
            && $st_more[1] == $st_less[1]
        );
    }
    else {
        return;
    }
}

sub fix_less {

    # We already know if this is set.
    return if $fixed_less;

    # changes environment!
    # 'r' added so we don't do (slow) stats again.
    $fixed_less = 1 if _calc_is_less();

    return;
} ## end sub fix_less

=head1 DIE AND WARN MANAGEMENT

=head2 C<diesignal>

C<diesignal> is a just-drop-dead C<die> handler. It's most useful when trying
to debug a debugger problem.

It does its best to report the error that occurred, and then forces the
program, debugger, and everything to die.

=cut

sub diesignal {

    # No entry/exit messages.
    local $frame = 0;

    # No return value prints.
    local $doret = -2;

    # set the abort signal handling to the default (just terminate).
    $SIG{'ABRT'} = 'DEFAULT';

    # If we enter the signal handler recursively, kill myself with an
    # abort signal (so we just terminate).
    kill 'ABRT', $$ if $panic++;

    # If we can show detailed info, do so.
    if ( defined &Carp::longmess ) {

        # Don't recursively enter the warn handler, since we're carping.
        local $SIG{__WARN__} = '';

        # Skip two levels before reporting traceback: we're skipping
        # mydie and confess.
        local $Carp::CarpLevel = 2;    # mydie + confess

        # Tell us all about it.
        _db_warn( Carp::longmess("Signal @_") );
    }

    # No Carp. Tell us about the signal as best we can.
    else {
        local $\ = '';
        print $DB::OUT "Got signal @_\n";
    }

    # Drop dead.
    kill 'ABRT', $$;
} ## end sub diesignal

=head2 C<dbwarn>

The debugger's own default C<$SIG{__WARN__}> handler. We load C<Carp> to
be able to get a stack trace, and output the warning message vi C<DB::dbwarn()>.

=cut

sub dbwarn {

    # No entry/exit trace.
    local $frame = 0;

    # No return value printing.
    local $doret = -2;

    # Turn off warn and die handling to prevent recursive entries to this
    # routine.
    local $SIG{__WARN__} = '';
    local $SIG{__DIE__}  = '';

    # Load Carp if we can. If $^S is false (current thing being compiled isn't
    # done yet), we may not be able to do a require.
    eval { require Carp }
      if defined $^S;    # If error/warning during compilation,
                         # require may be broken.

    # Use the core warn() unless Carp loaded OK.
    CORE::warn( @_,
        "\nCannot print stack trace, load with -MCarp option to see stack" ),
      return
      unless defined &Carp::longmess;

    # Save the current values of $single and $trace, and then turn them off.
    my ( $mysingle, $mytrace ) = ( $single, $trace );
    $single = 0;
    $trace  = 0;

    # We can call Carp::longmess without its being "debugged" (which we
    # don't want - we just want to use it!). Capture this for later.
    my $mess = Carp::longmess(@_);

    # Restore $single and $trace to their original values.
    ( $single, $trace ) = ( $mysingle, $mytrace );

    # Use the debugger's own special way of printing warnings to print
    # the stack trace message.
    _db_warn($mess);
} ## end sub dbwarn

=head2 C<dbdie>

The debugger's own C<$SIG{__DIE__}> handler. Handles providing a stack trace
by loading C<Carp> and calling C<Carp::longmess()> to get it. We turn off
single stepping and tracing during the call to C<Carp::longmess> to avoid
debugging it - we just want to use it.

If C<dieLevel> is zero, we let the program being debugged handle the
exceptions. If it's 1, you get backtraces for any exception. If it's 2,
the debugger takes over all exception handling, printing a backtrace and
displaying the exception via its C<dbwarn()> routine.

=cut

sub dbdie {
    local $frame         = 0;
    local $doret         = -2;
    local $SIG{__DIE__}  = '';
    local $SIG{__WARN__} = '';
    if ( $dieLevel > 2 ) {
        local $SIG{__WARN__} = \&dbwarn;
        _db_warn(@_);    # Yell no matter what
        return;
    }
    if ( $dieLevel < 2 ) {
        die @_ if $^S;    # in eval propagate
    }

    # The code used to check $^S to see if compilation of the current thing
    # hadn't finished. We don't do it anymore, figuring eval is pretty stable.
    eval { require Carp };

    die( @_,
        "\nCannot print stack trace, load with -MCarp option to see stack" )
      unless defined &Carp::longmess;

    # We do not want to debug this chunk (automatic disabling works
    # inside DB::DB, but not in Carp). Save $single and $trace, turn them off,
    # get the stack trace from Carp::longmess (if possible), restore $signal
    # and $trace, and then die with the stack trace.
    my ( $mysingle, $mytrace ) = ( $single, $trace );
    $single = 0;
    $trace  = 0;
    my $mess = "@_";
    {

        package Carp;    # Do not include us in the list
        eval { $mess = Carp::longmess(@_); };
    }
    ( $single, $trace ) = ( $mysingle, $mytrace );
    die $mess;
} ## end sub dbdie

=head2 C<warnlevel()>

Set the C<$DB::warnLevel> variable that stores the value of the
C<warnLevel> option. Calling C<warnLevel()> with a positive value
results in the debugger taking over all warning handlers. Setting
C<warnLevel> to zero leaves any warning handlers set up by the program
being debugged in place.

=cut

sub warnLevel {
    if (@_) {
        my $prevwarn = $SIG{__WARN__} unless $warnLevel;
        $warnLevel = shift;
        if ($warnLevel) {
            $SIG{__WARN__} = \&DB::dbwarn;
        }
        elsif ($prevwarn) {
            $SIG{__WARN__} = $prevwarn;
        } else {
            undef $SIG{__WARN__};
        }
    } ## end if (@_)
    $warnLevel;
} ## end sub warnLevel

=head2 C<dielevel>

Similar to C<warnLevel>. Non-zero values for C<dieLevel> result in the
C<DB::dbdie()> function overriding any other C<die()> handler. Setting it to
zero lets you use your own C<die()> handler.

=cut

sub dieLevel {
    local $\ = '';
    if (@_) {
        my $prevdie = $SIG{__DIE__} unless $dieLevel;
        $dieLevel = shift;
        if ($dieLevel) {

            # Always set it to dbdie() for non-zero values.
            $SIG{__DIE__} = \&DB::dbdie;    # if $dieLevel < 2;

            # No longer exists, so don't try  to use it.
            #$SIG{__DIE__} = \&DB::diehard if $dieLevel >= 2;

            # If we've finished initialization, mention that stack dumps
            # are enabled, If dieLevel is 1, we won't stack dump if we die
            # in an eval().
            print $OUT "Stack dump during die enabled",
              ( $dieLevel == 1 ? " outside of evals" : "" ), ".\n"
              if $I_m_init;

            # XXX This is probably obsolete, given that diehard() is gone.
            print $OUT "Dump printed too.\n" if $dieLevel > 2;
        } ## end if ($dieLevel)

        # Put the old one back if there was one.
        elsif ($prevdie) {
            $SIG{__DIE__} = $prevdie;
            print $OUT "Default die handler restored.\n";
        } else {
            undef $SIG{__DIE__};
            print $OUT "Die handler removed.\n";
        }
    } ## end if (@_)
    $dieLevel;
} ## end sub dieLevel

=head2 C<signalLevel>

Number three in a series: set C<signalLevel> to zero to keep your own
signal handler for C<SIGSEGV> and/or C<SIGBUS>. Otherwise, the debugger
takes over and handles them with C<DB::diesignal()>.

=cut

sub signalLevel {
    if (@_) {
        my $prevsegv = $SIG{SEGV} unless $signalLevel;
        my $prevbus  = $SIG{BUS}  unless $signalLevel;
        $signalLevel = shift;
        if ($signalLevel) {
            $SIG{SEGV} = \&DB::diesignal;
            $SIG{BUS}  = \&DB::diesignal;
        }
        else {
            $SIG{SEGV} = $prevsegv;
            $SIG{BUS}  = $prevbus;
        }
    } ## end if (@_)
    $signalLevel;
} ## end sub signalLevel

=head1 SUBROUTINE DECODING SUPPORT

These subroutines are used during the C<x> and C<X> commands to try to
produce as much information as possible about a code reference. They use
L<Devel::Peek> to try to find the glob in which this code reference lives
(if it does) - this allows us to actually code references which correspond
to named subroutines (including those aliased via glob assignment).

=head2 C<CvGV_name()>

Wrapper for C<CvGV_name_or_bust>; tries to get the name of a reference
via that routine. If this fails, return the reference again (when the
reference is stringified, it'll come out as C<SOMETHING(0x...)>).

=cut

sub CvGV_name {
    my $in   = shift;
    my $name = CvGV_name_or_bust($in);
    defined $name ? $name : $in;
}

=head2 C<CvGV_name_or_bust> I<coderef>

Calls L<Devel::Peek> to try to find the glob the ref lives in; returns
C<undef> if L<Devel::Peek> can't be loaded, or if C<Devel::Peek::CvGV> can't
find a glob for this ref.

Returns C<< I<package>::I<glob name> >> if the code ref is found in a glob.

=cut

use vars qw($skipCvGV);

sub CvGV_name_or_bust {
    my $in = shift;
    return if $skipCvGV;    # Backdoor to avoid problems if XS broken...
    return unless ref $in;
    $in = \&$in;            # Hard reference...
    eval { require Devel::Peek; 1 } or return;
    my $gv = Devel::Peek::CvGV($in) or return;
    *$gv{PACKAGE} . '::' . *$gv{NAME};
} ## end sub CvGV_name_or_bust

=head2 C<find_sub>

A utility routine used in various places; finds the file where a subroutine
was defined, and returns that filename and a line-number range.

Tries to use C<@sub> first; if it can't find it there, it tries building a
reference to the subroutine and uses C<CvGV_name_or_bust> to locate it,
loading it into C<@sub> as a side effect (XXX I think). If it can't find it
this way, it brute-force searches C<%sub>, checking for identical references.

=cut

sub _find_sub_helper {
    my $subr = shift;

    return unless defined &$subr;
    my $name = CvGV_name_or_bust($subr);
    my $data;
    $data = $sub{$name} if defined $name;
    return $data if defined $data;

    # Old stupid way...
    $subr = \&$subr;    # Hard reference
    my $s;
    for ( keys %sub ) {
        $s = $_, last if $subr eq \&$_;
    }
    if ($s)
    {
        return $sub{$s};
    }
    else
    {
        return;
    }

}

sub find_sub {
    my $subr = shift;
    return ( $sub{$subr} || _find_sub_helper($subr) );
} ## end sub find_sub

=head2 C<methods>

A subroutine that uses the utility function C<methods_via> to find all the
methods in the class corresponding to the current reference and in
C<UNIVERSAL>.

=cut

use vars qw(%seen);

sub methods {

    # Figure out the class - either this is the class or it's a reference
    # to something blessed into that class.
    my $class = shift;
    $class = ref $class if ref $class;

    local %seen;

    # Show the methods that this class has.
    methods_via( $class, '', 1 );

    # Show the methods that UNIVERSAL has.
    methods_via( 'UNIVERSAL', 'UNIVERSAL', 0 );
} ## end sub methods

=head2 C<methods_via($class, $prefix, $crawl_upward)>

C<methods_via> does the work of crawling up the C<@ISA> tree and reporting
all the parent class methods. C<$class> is the name of the next class to
try; C<$prefix> is the message prefix, which gets built up as we go up the
C<@ISA> tree to show parentage; C<$crawl_upward> is 1 if we should try to go
higher in the C<@ISA> tree, 0 if we should stop.

=cut

sub methods_via {

    # If we've processed this class already, just quit.
    my $class = shift;
    return if $seen{$class}++;

    # This is a package that is contributing the methods we're about to print.
    my $prefix  = shift;
    my $prepend = $prefix ? "via $prefix: " : '';
    my @to_print;

    # Extract from all the symbols in this class.
    my $class_ref = do { no strict "refs"; \%{$class . '::'} };
    while (my ($name, $glob) = each %$class_ref) {
        # references directly in the symbol table are Proxy Constant
        # Subroutines, and are by their very nature defined
        # Otherwise, check if the thing is a typeglob, and if it is, it decays
        # to a subroutine reference, which can be tested by defined.
        # $glob might also be the value -1  (from sub foo;)
        # or (say) '$$' (from sub foo ($$);)
        # \$glob will be SCALAR in both cases.
        if ((ref $glob || ($glob && ref \$glob eq 'GLOB' && defined &$glob))
            && !$seen{$name}++) {
            push @to_print, "$prepend$name\n";
        }
    }

    {
        local $\ = '';
        local $, = '';
        print $DB::OUT $_ foreach sort @to_print;
    }

    # If the $crawl_upward argument is false, just quit here.
    return unless shift;

    # $crawl_upward true: keep going up the tree.
    # Find all the classes this one is a subclass of.
    my $class_ISA_ref = do { no strict "refs"; \@{"${class}::ISA"} };
    for my $name ( @$class_ISA_ref ) {

        # Set up the new prefix.
        $prepend = $prefix ? $prefix . " -> $name" : $name;

        # Crawl up the tree and keep trying to crawl up.
        methods_via( $name, $prepend, 1 );
    }
} ## end sub methods_via

=head2 C<setman> - figure out which command to use to show documentation

Just checks the contents of C<$^O> and sets the C<$doccmd> global accordingly.

=cut

sub setman {
    $doccmd = $^O !~ /^(?:MSWin32|VMS|os2|amigaos|riscos)\z/s
      ? "man"         # O Happy Day!
      : "perldoc";    # Alas, poor unfortunates
} ## end sub setman

=head2 C<runman> - run the appropriate command to show documentation

Accepts a man page name; runs the appropriate command to display it (set up
during debugger initialization). Uses C<_db_system()> to avoid mucking up the
program's STDIN and STDOUT.

=cut

sub runman {
    my $page = shift;
    unless ($page) {
        _db_system("$doccmd $doccmd");
        return;
    }

    # this way user can override, like with $doccmd="man -Mwhatever"
    # or even just "man " to disable the path check.
    if ( $doccmd ne 'man' ) {
        _db_system("$doccmd $page");
        return;
    }

    $page = 'perl' if lc($page) eq 'help';

    require Config;
    my $man1dir = $Config::Config{man1direxp};
    my $man3dir = $Config::Config{man3direxp};
    for ( $man1dir, $man3dir ) { s#/[^/]*\z## if /\S/ }
    my $manpath = '';
    $manpath .= "$man1dir:" if $man1dir =~ /\S/;
    $manpath .= "$man3dir:" if $man3dir =~ /\S/ && $man1dir ne $man3dir;
    chop $manpath if $manpath;

    # harmless if missing, I figure
    local $ENV{MANPATH} = $manpath if $manpath;
    my $nopathopt = $^O =~ /dunno what goes here/;
    if (
        CORE::system(
            $doccmd,

            # I just *know* there are men without -M
            ( ( $manpath && !$nopathopt ) ? ( "-M", $manpath ) : () ),
            split ' ', $page
        )
      )
    {
        unless ( $page =~ /^perl\w/ ) {
            # Previously the debugger contained a list which it slurped in,
            # listing the known "perl" manpages. However, it was out of date,
            # with errors both of omission and inclusion. This approach is
            # considerably less complex. The failure mode on a butchered
            # install is simply that the user has to run man or perldoc
            # "manually" with the full manpage name.

            # There is a list of $^O values in installperl to determine whether
            # the directory is 'pods' or 'pod'. However, we can avoid tight
            # coupling to that by simply checking the "non-standard" 'pods'
            # first.
            my $pods = "$Config::Config{privlibexp}/pods";
            $pods = "$Config::Config{privlibexp}/pod"
                unless -d $pods;
            if (-f "$pods/perl$page.pod") {
                CORE::system( $doccmd,
                    ( ( $manpath && !$nopathopt ) ? ( "-M", $manpath ) : () ),
                    "perl$page" );
            }
        }
    } ## end if (CORE::system($doccmd...
} ## end sub runman

#use Carp;                          # This did break, left for debugging

=head1 DEBUGGER INITIALIZATION - THE SECOND BEGIN BLOCK

Because of the way the debugger interface to the Perl core is designed, any
debugger package globals that C<DB::sub()> requires have to be defined before
any subroutines can be called. These are defined in the second C<BEGIN> block.

This block sets things up so that (basically) the world is sane
before the debugger starts executing. We set up various variables that the
debugger has to have set up before the Perl core starts running:

=over 4

=item *

The debugger's own filehandles (copies of STD and STDOUT for now).

=item *

Characters for shell escapes, the recall command, and the history command.

=item *

The maximum recursion depth.

=item *

The size of a C<w> command's window.

=item *

The before-this-line context to be printed in a C<v> (view a window around this line) command.

=item *

The fact that we're not in a sub at all right now.

=item *

The default SIGINT handler for the debugger.

=item *

The appropriate value of the flag in C<$^D> that says the debugger is running

=item *

The current debugger recursion level

=item *

The list of postponed items and the C<$single> stack (XXX define this)

=item *

That we want no return values and no subroutine entry/exit trace.

=back

=cut

# The following BEGIN is very handy if debugger goes havoc, debugging debugger?

use vars qw($db_stop);

BEGIN {    # This does not compile, alas. (XXX eh?)
    $IN  = \*STDIN;     # For bugs before DB::OUT has been opened
    $OUT = \*STDERR;    # For errors before DB::OUT has been opened

    # Define characters used by command parsing.
    $sh       = '!';      # Shell escape (does not work)
    $rc       = ',';      # Recall command (does not work)
    @hist     = ('?');    # Show history (does not work)
    @truehist = ();       # Can be saved for replay (per session)

    # This defines the point at which you get the 'deep recursion'
    # warning. It MUST be defined or the debugger will not load.
    $deep = 1000;

    # Number of lines around the current one that are shown in the
    # 'w' command.
    $window = 10;

    # How much before-the-current-line context the 'v' command should
    # use in calculating the start of the window it will display.
    $preview = 3;

    # We're not in any sub yet, but we need this to be a defined value.
    $sub = '';

    # Set up the debugger's interrupt handler. It simply sets a flag
    # ($signal) that DB::DB() will check before each command is executed.
    $SIG{INT} = \&DB::catch;

    # The following lines supposedly, if uncommented, allow the debugger to
    # debug itself. Perhaps we can try that someday.
    # This may be enabled to debug debugger:
    #$warnLevel = 1 unless defined $warnLevel;
    #$dieLevel = 1 unless defined $dieLevel;
    #$signalLevel = 1 unless defined $signalLevel;

    # This is the flag that says "a debugger is running, please call
    # DB::DB and DB::sub". We will turn it on forcibly before we try to
    # execute anything in the user's context, because we always want to
    # get control back.
    $db_stop = 0;          # Compiler warning ...
    $db_stop = 1 << 30;    # ... because this is only used in an eval() later.

    # This variable records how many levels we're nested in debugging.
    # Used in the debugger prompt, and in determining whether it's all over or
    # not.
    $level = 0;            # Level of recursive debugging

    # "Triggers bug (?) in perl if we postpone this until runtime."
    # XXX No details on this yet, or whether we should fix the bug instead
    # of work around it. Stay tuned.
    @stack = (0);

    # Used to track the current stack depth using the auto-stacked-variable
    # trick.
    $stack_depth = 0;      # Localized repeatedly; simple way to track $#stack

    # Don't print return values on exiting a subroutine.
    $doret = -2;

    # No extry/exit tracing.
    $frame = 0;

} ## end BEGIN

BEGIN { $^W = $ini_warn; }    # Switch warnings back

=head1 READLINE SUPPORT - COMPLETION FUNCTION

=head2 db_complete

C<readline> support - adds command completion to basic C<readline>.

Returns a list of possible completions to C<readline> when invoked. C<readline>
will print the longest common substring following the text already entered.

If there is only a single possible completion, C<readline> will use it in full.

This code uses C<map> and C<grep> heavily to create lists of possible
completion. Think LISP in this section.

=cut

sub db_complete {

    # Specific code for b c l V m f O, &blah, $blah, @blah, %blah
    # $text is the text to be completed.
    # $line is the incoming line typed by the user.
    # $start is the start of the text to be completed in the incoming line.
    my ( $text, $line, $start ) = @_;

    # Save the initial text.
    # The search pattern is current package, ::, extract the next qualifier
    # Prefix and pack are set to undef.
    my ( $itext, $search, $prefix, $pack ) =
      ( $text, "^\Q${package}::\E([^:]+)\$" );

=head3 C<b postpone|compile>

=over 4

=item *

Find all the subroutines that might match in this package

=item *

Add C<postpone>, C<load>, and C<compile> as possibles (we may be completing the keyword itself)

=item *

Include all the rest of the subs that are known

=item *

C<grep> out the ones that match the text we have so far

=item *

Return this as the list of possible completions

=back

=cut

    return sort grep /^\Q$text/, ( keys %sub ),
      qw(postpone load compile),    # subroutines
      ( map { /$search/ ? ($1) : () } keys %sub )
      if ( substr $line, 0, $start ) =~ /^\|*[blc]\s+((postpone|compile)\s+)?$/;

=head3 C<b load>

Get all the possible files from C<@INC> as it currently stands and
select the ones that match the text so far.

=cut

    return sort grep /^\Q$text/, values %INC    # files
      if ( substr $line, 0, $start ) =~ /^\|*b\s+load\s+$/;

=head3  C<V> (list variable) and C<m> (list modules)

There are two entry points for these commands:

=head4 Unqualified package names

Get the top-level packages and grab everything that matches the text
so far. For each match, recursively complete the partial packages to
get all possible matching packages. Return this sorted list.

=cut

    return sort map { ( $_, db_complete( $_ . "::", "V ", 2 ) ) }
      grep /^\Q$text/, map { /^(.*)::$/ ? ($1) : () } keys %::    # top-packages
      if ( substr $line, 0, $start ) =~ /^\|*[Vm]\s+$/ and $text =~ /^\w*$/;

=head4 Qualified package names

Take a partially-qualified package and find all subpackages for it
by getting all the subpackages for the package so far, matching all
the subpackages against the text, and discarding all of them which
start with 'main::'. Return this list.

=cut

    return sort map { ( $_, db_complete( $_ . "::", "V ", 2 ) ) }
      grep !/^main::/, grep /^\Q$text/,
      map { /^(.*)::$/ ? ( $prefix . "::$1" ) : () }
      do { no strict 'refs'; keys %{ $prefix . '::' } }
      if ( substr $line, 0, $start ) =~ /^\|*[Vm]\s+$/
      and $text =~ /^(.*[^:])::?(\w*)$/
      and $prefix = $1;

=head3 C<f> - switch files

Here, we want to get a fully-qualified filename for the C<f> command.
Possibilities are:

=over 4

=item 1. The original source file itself

=item 2. A file from C<@INC>

=item 3. An C<eval> (the debugger gets a C<(eval N)> fake file for each C<eval>).

=back

=cut

    if ( $line =~ /^\|*f\s+(.*)/ ) {    # Loaded files
           # We might possibly want to switch to an eval (which has a "filename"
           # like '(eval 9)'), so we may need to clean up the completion text
           # before proceeding.
        $prefix = length($1) - length($text);
        $text   = $1;

=pod

Under the debugger, source files are represented as C<_E<lt>/fullpath/to/file>
(C<eval>s are C<_E<lt>(eval NNN)>) keys in C<%main::>. We pull all of these
out of C<%main::>, add the initial source file, and extract the ones that
match the completion text so far.

=cut

        return sort
          map { substr $_, 2 + $prefix } grep /^_<\Q$text/, ( keys %main:: ),
          $0;
    } ## end if ($line =~ /^\|*f\s+(.*)/)

=head3 Subroutine name completion

We look through all of the defined subs (the keys of C<%sub>) and
return both all the possible matches to the subroutine name plus
all the matches qualified to the current package.

=cut

    if ( ( substr $text, 0, 1 ) eq '&' ) {    # subroutines
        $text = substr $text, 1;
        $prefix = "&";
        return sort map "$prefix$_", grep /^\Q$text/, ( keys %sub ),
          (
            map { /$search/ ? ($1) : () }
              keys %sub
          );
    } ## end if ((substr $text, 0, ...

=head3  Scalar, array, and hash completion: partially qualified package

Much like the above, except we have to do a little more cleanup:

=cut

    if ( $text =~ /^[\$@%](.*)::(.*)/ ) {    # symbols in a package

=pod

=over 4

=item *

Determine the package that the symbol is in. Put it in C<::> (effectively C<main::>) if no package is specified.

=cut

        $pack = ( $1 eq 'main' ? '' : $1 ) . '::';

=pod

=item *

Figure out the prefix vs. what needs completing.

=cut

        $prefix = ( substr $text, 0, 1 ) . $1 . '::';
        $text   = $2;

=pod

=item *

Look through all the symbols in the package. C<grep> out all the possible hashes/arrays/scalars, and then C<grep> the possible matches out of those. C<map> the prefix onto all the possibilities.

=cut

        my @out = do {
            no strict 'refs';
            map "$prefix$_", grep /^\Q$text/, grep /^_?[a-zA-Z]/,
            keys %$pack;
        };

=pod

=item *

If there's only one hit, and it's a package qualifier, and it's not equal to the initial text, re-complete it using the symbol we actually found.

=cut

        if ( @out == 1 and $out[0] =~ /::$/ and $out[0] ne $itext ) {
            return db_complete( $out[0], $line, $start );
        }

        # Return the list of possibles.
        return sort @out;

    } ## end if ($text =~ /^[\$@%](.*)::(.*)/)

=pod

=back

=head3 Symbol completion: current package or package C<main>.

=cut

    if ( $text =~ /^[\$@%]/ ) {    # symbols (in $package + packages in main)
=pod

=over 4

=item *

If it's C<main>, delete main to just get C<::> leading.

=cut

        $pack = ( $package eq 'main' ? '' : $package ) . '::';

=pod

=item *

We set the prefix to the item's sigil, and trim off the sigil to get the text to be completed.

=cut

        $prefix = substr $text, 0, 1;
        $text   = substr $text, 1;

        my @out;

=pod

=item *

We look for the lexical scope above DB::DB and auto-complete lexical variables
if PadWalker could be loaded.

=cut

        if (not $text =~ /::/ and eval {
            local @INC = @INC;
            pop @INC if $INC[-1] eq '.';
            require PadWalker } ) {
            my $level = 1;
            while (1) {
                my @info = caller($level);
                $level++;
                $level = -1, last
                  if not @info;
                last if $info[3] eq 'DB::DB';
            }
            if ($level > 0) {
                my $lexicals = PadWalker::peek_my($level);
                push @out, grep /^\Q$prefix$text/, keys %$lexicals;
            }
        }

=pod

=item *

If the package is C<::> (C<main>), create an empty list; if it's something else, create a list of all the packages known.  Append whichever list to a list of all the possible symbols in the current package. C<grep> out the matches to the text entered so far, then C<map> the prefix back onto the symbols.

=cut

        push @out, map "$prefix$_", grep /^\Q$text/,
          ( grep /^_?[a-zA-Z]/, do { no strict 'refs'; keys %$pack } ),
          ( $pack eq '::' ? () : ( grep /::$/, keys %:: ) );

=item *

If there's only one hit, it's a package qualifier, and it's not equal to the initial text, recomplete using this symbol.

=back

=cut

        if ( @out == 1 and $out[0] =~ /::$/ and $out[0] ne $itext ) {
            return db_complete( $out[0], $line, $start );
        }

        # Return the list of possibles.
        return sort @out;
    } ## end if ($text =~ /^[\$@%]/)

=head3 Options

We use C<option_val()> to look up the current value of the option. If there's
only a single value, we complete the command in such a way that it is a
complete command for setting the option in question. If there are multiple
possible values, we generate a command consisting of the option plus a trailing
question mark, which, if executed, will list the current value of the option.

=cut

    if ( ( substr $line, 0, $start ) =~ /^\|*[oO]\b.*\s$/ )
    {    # Options after space
           # We look for the text to be matched in the list of possible options,
           # and fetch the current value.
        my @out = grep /^\Q$text/, @options;
        my $val = option_val( $out[0], undef );

        # Set up a 'query option's value' command.
        my $out = '? ';
        if ( not defined $val or $val =~ /[\n\r]/ ) {

            # There's really nothing else we can do.
        }

        # We have a value. Create a proper option-setting command.
        elsif ( $val =~ /\s/ ) {

            # XXX This may be an extraneous variable.
            my $found;

            # We'll want to quote the string (because of the embedded
            # whtespace), but we want to make sure we don't end up with
            # mismatched quote characters. We try several possibilities.
            foreach my $l ( split //, qq/\"\'\#\|/ ) {

                # If we didn't find this quote character in the value,
                # quote it using this quote character.
                $out = "$l$val$l ", last if ( index $val, $l ) == -1;
            }
        } ## end elsif ($val =~ /\s/)

        # Don't need any quotes.
        else {
            $out = "=$val ";
        }

        # If there were multiple possible values, return '? ', which
        # makes the command into a query command. If there was just one,
        # have readline append that.
        $rl_attribs->{completer_terminator_character} =
          ( @out == 1 ? $out : '? ' );

        # Return list of possibilities.
        return sort @out;
    } ## end if ((substr $line, 0, ...

=head3 Filename completion

For entering filenames. We simply call C<readline>'s C<filename_list()>
method with the completion text to get the possible completions.

=cut

    return $term->filename_list($text);    # filenames

} ## end sub db_complete

=head1 MISCELLANEOUS SUPPORT FUNCTIONS

Functions that possibly ought to be somewhere else.

=head2 end_report

Say we're done.

=cut

sub end_report {
    local $\ = '';
    print $OUT "Use 'q' to quit or 'R' to restart.  'h q' for details.\n";
}

=head2 clean_ENV

If we have $ini_pids, save it in the environment; else remove it from the
environment. Used by the C<R> (restart) command.

=cut

sub clean_ENV {
    if ( defined($ini_pids) ) {
        $ENV{PERLDB_PIDS} = $ini_pids;
    }
    else {
        delete( $ENV{PERLDB_PIDS} );
    }
} ## end sub clean_ENV

# PERLDBf_... flag names from perl.h
our ( %DollarCaretP_flags, %DollarCaretP_flags_r );

BEGIN {
    %DollarCaretP_flags = (
        PERLDBf_SUB       => 0x01,     # Debug sub enter/exit
        PERLDBf_LINE      => 0x02,     # Keep line #
        PERLDBf_NOOPT     => 0x04,     # Switch off optimizations
        PERLDBf_INTER     => 0x08,     # Preserve more data
        PERLDBf_SUBLINE   => 0x10,     # Keep subr source lines
        PERLDBf_SINGLE    => 0x20,     # Start with single-step on
        PERLDBf_NONAME    => 0x40,     # For _SUB: no name of the subr
        PERLDBf_GOTO      => 0x80,     # Report goto: call DB::goto
        PERLDBf_NAMEEVAL  => 0x100,    # Informative names for evals
        PERLDBf_NAMEANON  => 0x200,    # Informative names for anon subs
        PERLDBf_SAVESRC   => 0x400,    # Save source lines into @{"_<$filename"}
        PERLDB_ALL        => 0x33f,    # No _NONAME, _GOTO
    );
    # PERLDBf_LINE also enables the actions of PERLDBf_SAVESRC, so the debugger
    # doesn't need to set it. It's provided for the benefit of profilers and
    # other code analysers.

    %DollarCaretP_flags_r = reverse %DollarCaretP_flags;
}

sub parse_DollarCaretP_flags {
    my $flags = shift;
    $flags =~ s/^\s+//;
    $flags =~ s/\s+$//;
    my $acu = 0;
    foreach my $f ( split /\s*\|\s*/, $flags ) {
        my $value;
        if ( $f =~ /^0x([[:xdigit:]]+)$/ ) {
            $value = hex $1;
        }
        elsif ( $f =~ /^(\d+)$/ ) {
            $value = int $1;
        }
        elsif ( $f =~ /^DEFAULT$/i ) {
            $value = $DollarCaretP_flags{PERLDB_ALL};
        }
        else {
            $f =~ /^(?:PERLDBf_)?(.*)$/i;
            $value = $DollarCaretP_flags{ 'PERLDBf_' . uc($1) };
            unless ( defined $value ) {
                print $OUT (
                    "Unrecognized \$^P flag '$f'!\n",
                    "Acceptable flags are: "
                      . join( ', ', sort keys %DollarCaretP_flags ),
                    ", and hexadecimal and decimal numbers.\n"
                );
                return undef;
            }
        }
        $acu |= $value;
    }
    $acu;
}

sub expand_DollarCaretP_flags {
    my $DollarCaretP = shift;
    my @bits         = (
        map {
            my $n = ( 1 << $_ );
            ( $DollarCaretP & $n )
              ? ( $DollarCaretP_flags_r{$n}
                  || sprintf( '0x%x', $n ) )
              : ()
          } 0 .. 31
    );
    return @bits ? join( '|', @bits ) : 0;
}

=over 4

=item rerun

Rerun the current session to:

    rerun        current position

    rerun 4      command number 4

    rerun -4     current command minus 4 (go back 4 steps)

Whether this always makes sense, in the current context is unknowable, and is
in part left as a useful exercise for the reader.  This sub returns the
appropriate arguments to rerun the current session.

=cut

sub rerun {
    my $i = shift;
    my @args;
    pop(@truehist);                      # strim
    unless (defined $truehist[$i]) {
        print "Unable to return to non-existent command: $i\n";
    } else {
        $#truehist = ($i < 0 ? $#truehist + $i : $i > 0 ? $i : $#truehist);
        my @temp = @truehist;            # store
        push(@DB::typeahead, @truehist); # saved
        @truehist = @hist = ();          # flush
        @args = restart();              # setup
        get_list("PERLDB_HIST");        # clean
        set_list("PERLDB_HIST", @temp); # reset
    }
    return @args;
}

=item restart

Restarting the debugger is a complex operation that occurs in several phases.
First, we try to reconstruct the command line that was used to invoke Perl
and the debugger.

=cut

sub restart {
    # I may not be able to resurrect you, but here goes ...
    print $OUT
"Warning: some settings and command-line options may be lost!\n";
    my ( @script, @flags, $cl );

    # If warn was on before, turn it on again.
    push @flags, '-w' if $ini_warn;

    # Rebuild the -I flags that were on the initial
    # command line.
    for (@ini_INC) {
        push @flags, '-I', $_;
    }

    # Turn on taint if it was on before.
    push @flags, '-T' if ${^TAINT};

    # Arrange for setting the old INC:
    # Save the current @init_INC in the environment.
    set_list( "PERLDB_INC", @ini_INC );

    # If this was a perl one-liner, go to the "file"
    # corresponding to the one-liner read all the lines
    # out of it (except for the first one, which is going
    # to be added back on again when 'perl -d' runs: that's
    # the 'require perl5db.pl;' line), and add them back on
    # to the command line to be executed.
    if ( $0 eq '-e' ) {
        my $lines = *{$main::{'_<-e'}}{ARRAY};
        for ( 1 .. $#$lines ) {  # The first line is PERL5DB
            chomp( $cl = $lines->[$_] );
            push @script, '-e', $cl;
        }
    } ## end if ($0 eq '-e')

    # Otherwise we just reuse the original name we had
    # before.
    else {
        @script = $0;
    }

=pod

After the command line  has been reconstructed, the next step is to save
the debugger's status in environment variables. The C<DB::set_list> routine
is used to save aggregate variables (both hashes and arrays); scalars are
just popped into environment variables directly.

=cut

    # If the terminal supported history, grab it and
    # save that in the environment.
    set_list( "PERLDB_HIST",
          $term->Features->{getHistory}
        ? $term->GetHistory
        : @hist );

    # Find all the files that were visited during this
    # session (i.e., the debugger had magic hashes
    # corresponding to them) and stick them in the environment.
    my @had_breakpoints = keys %had_breakpoints;
    set_list( "PERLDB_VISITED", @had_breakpoints );

    # Save the debugger options we chose.
    set_list( "PERLDB_OPT", %option );
    # set_list( "PERLDB_OPT", options2remember() );

    # Save the break-on-loads.
    set_list( "PERLDB_ON_LOAD", %break_on_load );

=pod

The most complex part of this is the saving of all of the breakpoints. They
can live in an awful lot of places, and we have to go through all of them,
find the breakpoints, and then save them in the appropriate environment
variable via C<DB::set_list>.

=cut

    # Go through all the breakpoints and make sure they're
    # still valid.
    my @hard;
    for ( 0 .. $#had_breakpoints ) {

        # We were in this file.
        my $file = $had_breakpoints[$_];

        # Grab that file's magic line hash.
        *dbline = $main::{ '_<' . $file };

        # Skip out if it doesn't exist, or if the breakpoint
        # is in a postponed file (we'll do postponed ones
        # later).
        next unless %dbline or $postponed_file{$file};

        # In an eval. This is a little harder, so we'll
        # do more processing on that below.
        ( push @hard, $file ), next
          if $file =~ /^\(\w*eval/;

        # XXX I have no idea what this is doing. Yet.
        my @add;
        @add = %{ $postponed_file{$file} }
          if $postponed_file{$file};

        # Save the list of all the breakpoints for this file.
        set_list( "PERLDB_FILE_$_", %dbline, @add );

        # Serialize the extra data %breakpoints_data hash.
        # That's a bug fix.
        set_list( "PERLDB_FILE_ENABLED_$_",
            map { _is_breakpoint_enabled($file, $_) ? 1 : 0 }
            sort { $a <=> $b } keys(%dbline)
        )
    } ## end for (0 .. $#had_breakpoints)

    # The breakpoint was inside an eval. This is a little
    # more difficult. XXX and I don't understand it.
    foreach my $hard_file (@hard) {
        # Get over to the eval in question.
        *dbline = $main::{ '_<' . $hard_file };
        my $quoted = quotemeta $hard_file;
        my %subs;
        for my $sub ( keys %sub ) {
            if (my ($n1, $n2) = $sub{$sub} =~ /\A$quoted:(\d+)-(\d+)\z/) {
                $subs{$sub} = [ $n1, $n2 ];
            }
        }
        unless (%subs) {
            print {$OUT}
            "No subroutines in $hard_file, ignoring breakpoints.\n";
            next;
        }
        LINES: foreach my $line ( keys %dbline ) {

            # One breakpoint per sub only:
            my ( $offset, $found );
            SUBS: foreach my $sub ( keys %subs ) {
                if (
                    $subs{$sub}->[1] >= $line    # Not after the subroutine
                    and (
                        not defined $offset    # Not caught
                            or $offset < 0
                    )
                )
                {                              # or badly caught
                    $found  = $sub;
                    $offset = $line - $subs{$sub}->[0];
                    if ($offset >= 0) {
                        $offset = "+$offset";
                        last SUBS;
                    }
                } ## end if ($subs{$sub}->[1] >=...
            } ## end for $sub (keys %subs)
            if ( defined $offset ) {
                $postponed{$found} =
                "break $offset if $dbline{$line}";
            }
            else {
                print {$OUT}
                ("Breakpoint in ${hard_file}:$line ignored:"
                . " after all the subroutines.\n");
            }
        } ## end for $line (keys %dbline)
    } ## end for (@hard)

    # Save the other things that don't need to be
    # processed.
    set_list( "PERLDB_POSTPONE",  %postponed );
    set_list( "PERLDB_PRETYPE",   @$pretype );
    set_list( "PERLDB_PRE",       @$pre );
    set_list( "PERLDB_POST",      @$post );
    set_list( "PERLDB_TYPEAHEAD", @typeahead );

    # We are officially restarting.
    $ENV{PERLDB_RESTART} = 1;

    # We are junking all child debuggers.
    delete $ENV{PERLDB_PIDS};    # Restore ini state

    # Set this back to the initial pid.
    $ENV{PERLDB_PIDS} = $ini_pids if defined $ini_pids;

=pod

After all the debugger status has been saved, we take the command we built up
and then return it, so we can C<exec()> it. The debugger will spot the
C<PERLDB_RESTART> environment variable and realize it needs to reload its state
from the environment.

=cut

    # And run Perl again. Add the "-d" flag, all the
    # flags we built up, the script (whether a one-liner
    # or a file), add on the -emacs flag for a client editor,
    # and then the old arguments.

    return ($^X, '-d', @flags, @script, ($client_editor ? '-emacs' : ()), @ARGS);

};  # end restart

=back

=head1 END PROCESSING - THE C<END> BLOCK

Come here at the very end of processing. We want to go into a
loop where we allow the user to enter commands and interact with the
debugger, but we don't want anything else to execute.

First we set the C<$finished> variable, so that some commands that
shouldn't be run after the end of program quit working.

We then figure out whether we're truly done (as in the user entered a C<q>
command, or we finished execution while running nonstop). If we aren't,
we set C<$single> to 1 (causing the debugger to get control again).

We then call C<DB::fake::at_exit()>, which returns the C<Use 'q' to quit ...>
message and returns control to the debugger. Repeat.

When the user finally enters a C<q> command, C<$fall_off_end> is set to
1 and the C<END> block simply exits with C<$single> set to 0 (don't
break, run to completion.).

=cut

END {
    $finished = 1 if $inhibit_exit;    # So that some commands may be disabled.
    $fall_off_end = 1 unless $inhibit_exit;

    # Do not stop in at_exit() and destructors on exit:
    if ($fall_off_end or $runnonstop) {
        save_hist();
    } else {
        $DB::single = 1;
        DB::fake::at_exit();
    }
} ## end END

=head1 PRE-5.8 COMMANDS

Some of the commands changed function quite a bit in the 5.8 command
realignment, so much so that the old code had to be replaced completely.
Because we wanted to retain the option of being able to go back to the
former command set, we moved the old code off to this section.

There's an awful lot of duplicated code here. We've duplicated the
comments to keep things clear.

=head2 Null command

Does nothing. Used to I<turn off> commands.

=cut

sub cmd_pre580_null {

    # do nothing...
}

=head2 Old C<a> command.

This version added actions if you supplied them, and deleted them
if you didn't.

=cut

sub cmd_pre580_a {
    my $xcmd = shift;
    my $cmd  = shift;

    # Argument supplied. Add the action.
    if ( $cmd =~ /^(\d*)\s*(.*)/ ) {

        # If the line isn't there, use the current line.
        my $i = $1 || $line;
        my $j = $2;

        # If there is an action ...
        if ( length $j ) {

            # ... but the line isn't breakable, skip it.
            if ( $dbline[$i] == 0 ) {
                print $OUT "Line $i may not have an action.\n";
            }
            else {

                # ... and the line is breakable:
                # Mark that there's an action in this file.
                $had_breakpoints{$filename} |= 2;

                # Delete any current action.
                $dbline{$i} =~ s/\0[^\0]*//;

                # Add the new action, continuing the line as needed.
                $dbline{$i} .= "\0" . action($j);
            }
        } ## end if (length $j)

        # No action supplied.
        else {

            # Delete the action.
            $dbline{$i} =~ s/\0[^\0]*//;

            # Mark as having no break or action if nothing's left.
            delete $dbline{$i} if $dbline{$i} eq '';
        }
    } ## end if ($cmd =~ /^(\d*)\s*(.*)/)
} ## end sub cmd_pre580_a

=head2 Old C<b> command

Add breakpoints.

=cut

sub cmd_pre580_b {
    my $xcmd   = shift;
    my $cmd    = shift;
    my $dbline = shift;

    # Break on load.
    if ( $cmd =~ /^load\b\s*(.*)/ ) {
        my $file = $1;
        $file =~ s/\s+$//;
        cmd_b_load($file);
    }

    # b compile|postpone <some sub> [<condition>]
    # The interpreter actually traps this one for us; we just put the
    # necessary condition in the %postponed hash.
    elsif ( $cmd =~ /^(postpone|compile)\b\s*([':A-Za-z_][':\w]*)\s*(.*)/ ) {

        # Capture the condition if there is one. Make it true if none.
        my $cond = length $3 ? $3 : '1';

        # Save the sub name and set $break to 1 if $1 was 'postpone', 0
        # if it was 'compile'.
        my ( $subname, $break ) = ( $2, $1 eq 'postpone' );

        # De-Perl4-ify the name - ' separators to ::.
        $subname =~ s/\'/::/g;

        # Qualify it into the current package unless it's already qualified.
        $subname = "${package}::" . $subname
          unless $subname =~ /::/;

        # Add main if it starts with ::.
        $subname = "main" . $subname if substr( $subname, 0, 2 ) eq "::";

        # Save the break type for this sub.
        $postponed{$subname} = $break ? "break +0 if $cond" : "compile";
    } ## end elsif ($cmd =~ ...

    # b <sub name> [<condition>]
    elsif ( $cmd =~ /^([':A-Za-z_][':\w]*(?:\[.*\])?)\s*(.*)/ ) {
        my $subname = $1;
        my $cond = length $2 ? $2 : '1';
        cmd_b_sub( $subname, $cond );
    }
    # b <line> [<condition>].
    elsif ( $cmd =~ /^(\d*)\s*(.*)/ ) {
        my $i = $1 || $dbline;
        my $cond = length $2 ? $2 : '1';
        cmd_b_line( $i, $cond );
    }
} ## end sub cmd_pre580_b

=head2 Old C<D> command.

Delete all breakpoints unconditionally.

=cut

sub cmd_pre580_D {
    my $xcmd = shift;
    my $cmd  = shift;
    if ( $cmd =~ /^\s*$/ ) {
        print $OUT "Deleting all breakpoints...\n";

        # %had_breakpoints lists every file that had at least one
        # breakpoint in it.
        my $file;
        for $file ( keys %had_breakpoints ) {

            # Switch to the desired file temporarily.
            local *dbline = $main::{ '_<' . $file };

            $max = $#dbline;
            my $was;

            # For all lines in this file ...
            for my $i (1 .. $max) {

                # If there's a breakpoint or action on this line ...
                if ( defined $dbline{$i} ) {

                    # ... remove the breakpoint.
                    $dbline{$i} =~ s/^[^\0]+//;
                    if ( $dbline{$i} =~ s/^\0?$// ) {

                        # Remove the entry altogether if no action is there.
                        delete $dbline{$i};
                    }
                } ## end if (defined $dbline{$i...
            } ## end for my $i (1 .. $max)

            # If, after we turn off the "there were breakpoints in this file"
            # bit, the entry in %had_breakpoints for this file is zero,
            # we should remove this file from the hash.
            if ( not $had_breakpoints{$file} &= ~1 ) {
                delete $had_breakpoints{$file};
            }
        } ## end for $file (keys %had_breakpoints)

        # Kill off all the other breakpoints that are waiting for files that
        # haven't been loaded yet.
        undef %postponed;
        undef %postponed_file;
        undef %break_on_load;
    } ## end if ($cmd =~ /^\s*$/)
} ## end sub cmd_pre580_D

=head2 Old C<h> command

Print help. Defaults to printing the long-form help; the 5.8 version
prints the summary by default.

=cut

sub cmd_pre580_h {
    my $xcmd = shift;
    my $cmd  = shift;

    # Print the *right* help, long format.
    if ( $cmd =~ /^\s*$/ ) {
        print_help($pre580_help);
    }

    # 'h h' - explicitly-requested summary.
    elsif ( $cmd =~ /^h\s*/ ) {
        print_help($pre580_summary);
    }

    # Find and print a command's help.
    elsif ( $cmd =~ /^h\s+(\S.*)$/ ) {
        my $asked  = $1;                   # for proper errmsg
        my $qasked = quotemeta($asked);    # for searching
                                           # XXX: finds CR but not <CR>
        if (
            $pre580_help =~ /^
                              <?           # Optional '<'
                              (?:[IB]<)    # Optional markup
                              $qasked      # The command name
                            /mx
          )
        {

            while (
                $pre580_help =~ /^
                                  (             # The command help:
                                   <?           # Optional '<'
                                   (?:[IB]<)    # Optional markup
                                   $qasked      # The command name
                                   ([\s\S]*?)   # Lines starting with tabs
                                   \n           # Final newline
                                  )
                                  (?!\s)/mgx
              )    # Line not starting with space
                   # (Next command's help)
            {
                print_help($1);
            }
        } ## end if ($pre580_help =~ /^<?(?:[IB]<)$qasked/m)

        # Help not found.
        else {
            print_help("B<$asked> is not a debugger command.\n");
        }
    } ## end elsif ($cmd =~ /^h\s+(\S.*)$/)
} ## end sub cmd_pre580_h

=head2 Old C<W> command

C<W E<lt>exprE<gt>> adds a watch expression, C<W> deletes them all.

=cut

sub cmd_pre580_W {
    my $xcmd = shift;
    my $cmd  = shift;

    # Delete all watch expressions.
    if ( $cmd =~ /^$/ ) {

        # No watching is going on.
        $trace &= ~2;

        # Kill all the watch expressions and values.
        @to_watch = @old_watch = ();
    }

    # Add a watch expression.
    elsif ( $cmd =~ /^(.*)/s ) {

        # add it to the list to be watched.
        push @to_watch, $1;

        # Get the current value of the expression.
        # Doesn't handle expressions returning list values!
        $evalarg = $1;
        # The &-call is here to ascertain the mutability of @_.
        my ($val) = &DB::eval;
        $val = ( defined $val ) ? "'$val'" : 'undef';

        # Save it.
        push @old_watch, $val;

        # We're watching stuff.
        $trace |= 2;

    } ## end elsif ($cmd =~ /^(.*)/s)
} ## end sub cmd_pre580_W

=head1 PRE-AND-POST-PROMPT COMMANDS AND ACTIONS

The debugger used to have a bunch of nearly-identical code to handle
the pre-and-post-prompt action commands. C<cmd_pre590_prepost> and
C<cmd_prepost> unify all this into one set of code to handle the
appropriate actions.

=head2 C<cmd_pre590_prepost>

A small wrapper around C<cmd_prepost>; it makes sure that the default doesn't
do something destructive. In pre 5.8 debuggers, the default action was to
delete all the actions.

=cut

sub cmd_pre590_prepost {
    my $cmd    = shift;
    my $line   = shift || '*';
    my $dbline = shift;

    return cmd_prepost( $cmd, $line, $dbline );
} ## end sub cmd_pre590_prepost

=head2 C<cmd_prepost>

Actually does all the handling for C<E<lt>>, C<E<gt>>, C<{{>, C<{>, etc.
Since the lists of actions are all held in arrays that are pointed to by
references anyway, all we have to do is pick the right array reference and
then use generic code to all, delete, or list actions.

=cut

sub cmd_prepost {
    my $cmd = shift;

    # No action supplied defaults to 'list'.
    my $line = shift || '?';

    # Figure out what to put in the prompt.
    my $which = '';

    # Make sure we have some array or another to address later.
    # This means that if for some reason the tests fail, we won't be
    # trying to stash actions or delete them from the wrong place.
    my $aref = [];

    # < - Perl code to run before prompt.
    if ( $cmd =~ /^\</o ) {
        $which = 'pre-perl';
        $aref  = $pre;
    }

    # > - Perl code to run after prompt.
    elsif ( $cmd =~ /^\>/o ) {
        $which = 'post-perl';
        $aref  = $post;
    }

    # { - first check for properly-balanced braces.
    elsif ( $cmd =~ /^\{/o ) {
        if ( $cmd =~ /^\{.*\}$/o && unbalanced( substr( $cmd, 1 ) ) ) {
            print $OUT
"$cmd is now a debugger command\nuse ';$cmd' if you mean Perl code\n";
        }

        # Properly balanced. Pre-prompt debugger actions.
        else {
            $which = 'pre-debugger';
            $aref  = $pretype;
        }
    } ## end elsif ( $cmd =~ /^\{/o )

    # Did we find something that makes sense?
    unless ($which) {
        print $OUT "Confused by command: $cmd\n";
    }

    # Yes.
    else {

        # List actions.
        if ( $line =~ /^\s*\?\s*$/o ) {
            unless (@$aref) {

                # Nothing there. Complain.
                print $OUT "No $which actions.\n";
            }
            else {

                # List the actions in the selected list.
                print $OUT "$which commands:\n";
                foreach my $action (@$aref) {
                    print $OUT "\t$cmd -- $action\n";
                }
            } ## end else
        } ## end if ( $line =~ /^\s*\?\s*$/o)

        # Might be a delete.
        else {
            if ( length($cmd) == 1 ) {
                if ( $line =~ /^\s*\*\s*$/o ) {

                    # It's a delete. Get rid of the old actions in the
                    # selected list..
                    @$aref = ();
                    print $OUT "All $cmd actions cleared.\n";
                }
                else {

                    # Replace all the actions. (This is a <, >, or {).
                    @$aref = action($line);
                }
            } ## end if ( length($cmd) == 1)
            elsif ( length($cmd) == 2 ) {

                # Add the action to the line. (This is a <<, >>, or {{).
                push @$aref, action($line);
            }
            else {

                # <<<, >>>>, {{{{{{ ... something not a command.
                print $OUT
                  "Confused by strange length of $which command($cmd)...\n";
            }
        } ## end else [ if ( $line =~ /^\s*\?\s*$/o)
    } ## end else
} ## end sub cmd_prepost

=head1 C<DB::fake>

Contains the C<at_exit> routine that the debugger uses to issue the
C<Debugged program terminated ...> message after the program completes. See
the C<END> block documentation for more details.

=cut

package DB::fake;

sub at_exit {
    "Debugged program terminated.  Use 'q' to quit or 'R' to restart.";
}

package DB;    # Do not trace this 1; below!

1;


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (**************************************************************************)
(*                                                                        *)
(*                                 OCaml                                  *)
(*                                                                        *)
(*             Xavier Leroy, projet Cristal, INRIA Rocquencourt           *)
(*                                                                        *)
(*   Copyright 1996 Institut National de Recherche en Informatique et     *)
(*     en Automatique.                                                    *)
(*                                                                        *)
(*   All rights reserved.  This file is distributed under the terms of    *)
(*   the GNU Lesser General Public License version 2.1, with the          *)
(*   special exception on linking described in the file LICENSE.          *)
(*                                                                        *)
(**************************************************************************)

(* NOTE: If this file is set.mli, do not edit it directly! Instead,
   edit templates/set.template.mli and run tools/sync_stdlib_docs *)

(** Sets over ordered types.

   This module implements the set data structure, given a total ordering
   function over the set elements. All operations over sets
   are purely applicative (no side-effects).
   The implementation uses balanced binary trees, and is therefore
   reasonably efficient: insertion and membership take time
   logarithmic in the size of the set, for instance.

   The {!Make} functor constructs implementations for any type, given a
   [compare] function.
   For instance:
   {[
     module IntPairs =
       struct
         type t = int * int
         let compare (x0,y0) (x1,y1) =
           match Stdlib.compare x0 x1 with
               0 -> Stdlib.compare y0 y1
             | c -> c
       end

     module PairsSet = Set.Make(IntPairs)

     let m = PairsSet.(empty |> add (2,3) |> add (5,7) |> add (11,13))
   ]}

   This creates a new module [PairsSet], with a new type [PairsSet.t]
   of sets of [int * int].
*)

module type OrderedType =
  sig
    type t
      (** The type of the set elements. *)

    val compare : t -> t -> int
      (** A total ordering function over the set elements.
          This is a two-argument function [f] such that
          [f e1 e2] is zero if the elements [e1] and [e2] are equal,
          [f e1 e2] is strictly negative if [e1] is smaller than [e2],
          and [f e1 e2] is strictly positive if [e1] is greater than [e2].
          Example: a suitable ordering function is the generic structural
          comparison function {!Stdlib.compare}. *)
  end
(** Input signature of the functor {!Make}. *)

module type S =
  sig
    type elt
    (** The type of the set elements. *)

    type t
    (** The type of sets. *)

    val empty: t
    (** The empty set. *)

    val is_empty: t -> bool
    (** Test whether a set is empty or not. *)

    val mem: elt -> t -> bool
    (** [mem x s] tests whether [x] belongs to the set [s]. *)

    val add: elt -> t -> t
    (** [add x s] returns a set containing all elements of [s],
       plus [x]. If [x] was already in [s], [s] is returned unchanged
       (the result of the function is then physically equal to [s]).
       @before 4.03 Physical equality was not ensured. *)

    val singleton: elt -> t
    (** [singleton x] returns the one-element set containing only [x]. *)

    val remove: elt -> t -> t
    (** [remove x s] returns a set containing all elements of [s],
       except [x]. If [x] was not in [s], [s] is returned unchanged
       (the result of the function is then physically equal to [s]).
       @before 4.03 Physical equality was not ensured. *)

    val union: t -> t -> t
    (** Set union. *)

    val inter: t -> t -> t
    (** Set intersection. *)

    val disjoint: t -> t -> bool
    (** Test if two sets are disjoint.
        @since 4.08.0 *)

    val diff: t -> t -> t
    (** Set difference: [diff s1 s2] contains the elements of [s1]
       that are not in [s2]. *)

    val compare: t -> t -> int
    (** Total ordering between sets. Can be used as the ordering function
       for doing sets of sets. *)

    val equal: t -> t -> bool
    (** [equal s1 s2] tests whether the sets [s1] and [s2] are
       equal, that is, contain equal elements. *)

    val subset: t -> t -> bool
    (** [subset s1 s2] tests whether the set [s1] is a subset of
       the set [s2]. *)

    val iter: (elt -> unit) -> t -> unit
    (** [iter f s] applies [f] in turn to all elements of [s].
       The elements of [s] are presented to [f] in increasing order
       with respect to the ordering over the type of the elements. *)

    val map: (elt -> elt) -> t -> t
    (** [map f s] is the set whose elements are [f a0],[f a1]... [f
        aN], where [a0],[a1]...[aN] are the elements of [s].

       The elements are passed to [f] in increasing order
       with respect to the ordering over the type of the elements.

       If no element of [s] is changed by [f], [s] is returned
       unchanged. (If each output of [f] is physically equal to its
       input, the returned set is physically equal to [s].)
       @since 4.04.0 *)

    val fold: (elt -> 'a -> 'a) -> t -> 'a -> 'a
    (** [fold f s init] computes [(f xN ... (f x2 (f x1 init))...)],
       where [x1 ... xN] are the elements of [s], in increasing order. *)

    val for_all: (elt -> bool) -> t -> bool
    (** [for_all f s] checks if all elements of the set
       satisfy the predicate [f]. *)

    val exists: (elt -> bool) -> t -> bool
    (** [exists f s] checks if at least one element of
       the set satisfies the predicate [f]. *)

    val filter: (elt -> bool) -> t -> t
    (** [filter f s] returns the set of all elements in [s]
       that satisfy predicate [f]. If [f] satisfies every element in [s],
       [s] is returned unchanged (the result of the function is then
       physically equal to [s]).
       @before 4.03 Physical equality was not ensured.*)

    val filter_map: (elt -> elt option) -> t -> t
    (** [filter_map f s] returns the set of all [v] such that
        [f x = Some v] for some element [x] of [s].

       For example,
       {[filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) s]}
       is the set of halves of the even elements of [s].

       If no element of [s] is changed or dropped by [f] (if
       [f x = Some x] for each element [x]), then
       [s] is returned unchanged: the result of the function
       is then physically equal to [s].

       @since 4.11.0
     *)

    val partition: (elt -> bool) -> t -> t * t
    (** [partition f s] returns a pair of sets [(s1, s2)], where
       [s1] is the set of all the elements of [s] that satisfy the
       predicate [f], and [s2] is the set of all the elements of
       [s] that do not satisfy [f]. *)

    val cardinal: t -> int
    (** Return the number of elements of a set. *)

    val elements: t -> elt list
    (** Return the list of all elements of the given set.
       The returned list is sorted in increasing order with respect
       to the ordering [Ord.compare], where [Ord] is the argument
       given to {!Make}. *)

    val min_elt: t -> elt
    (** Return the smallest element of the given set
       (with respect to the [Ord.compare] ordering), or raise
       [Not_found] if the set is empty. *)

    val min_elt_opt: t -> elt option
    (** Return the smallest element of the given set
       (with respect to the [Ord.compare] ordering), or [None]
       if the set is empty.
        @since 4.05
    *)

    val max_elt: t -> elt
    (** Same as {!S.min_elt}, but returns the largest element of the
       given set. *)

    val max_elt_opt: t -> elt option
    (** Same as {!S.min_elt_opt}, but returns the largest element of the
        given set.
        @since 4.05
    *)

    val choose: t -> elt
    (** Return one element of the given set, or raise [Not_found] if
       the set is empty. Which element is chosen is unspecified,
       but equal elements will be chosen for equal sets. *)

    val choose_opt: t -> elt option
    (** Return one element of the given set, or [None] if
        the set is empty. Which element is chosen is unspecified,
        but equal elements will be chosen for equal sets.
        @since 4.05
    *)

    val split: elt -> t -> t * bool * t
    (** [split x s] returns a triple [(l, present, r)], where
          [l] is the set of elements of [s] that are
          strictly less than [x];
          [r] is the set of elements of [s] that are
          strictly greater than [x];
          [present] is [false] if [s] contains no element equal to [x],
          or [true] if [s] contains an element equal to [x]. *)

    val find: elt -> t -> elt
    (** [find x s] returns the element of [s] equal to [x] (according
        to [Ord.compare]), or raise [Not_found] if no such element
        exists.
        @since 4.01.0 *)

    val find_opt: elt -> t -> elt option
    (** [find_opt x s] returns the element of [s] equal to [x] (according
        to [Ord.compare]), or [None] if no such element
        exists.
        @since 4.05 *)

    val find_first: (elt -> bool) -> t -> elt
    (** [find_first f s], where [f] is a monotonically increasing function,
       returns the lowest element [e] of [s] such that [f e],
       or raises [Not_found] if no such element exists.

       For example, [find_first (fun e -> Ord.compare e x >= 0) s] will return
       the first element [e] of [s] where [Ord.compare e x >= 0] (intuitively:
       [e >= x]), or raise [Not_found] if [x] is greater than any element of
       [s].

        @since 4.05
       *)

    val find_first_opt: (elt -> bool) -> t -> elt option
    (** [find_first_opt f s], where [f] is a monotonically increasing
       function, returns an option containing the lowest element [e] of [s]
       such that [f e], or [None] if no such element exists.
        @since 4.05
       *)

    val find_last: (elt -> bool) -> t -> elt
    (** [find_last f s], where [f] is a monotonically decreasing function,
       returns the highest element [e] of [s] such that [f e],
       or raises [Not_found] if no such element exists.
        @since 4.05
       *)

    val find_last_opt: (elt -> bool) -> t -> elt option
    (** [find_last_opt f s], where [f] is a monotonically decreasing
       function, returns an option containing the highest element [e] of [s]
       such that [f e], or [None] if no such element exists.
        @since 4.05
       *)

    val of_list: elt list -> t
    (** [of_list l] creates a set from a list of elements.
        This is usually more efficient than folding [add] over the list,
        except perhaps for lists with many duplicated elements.
        @since 4.02.0 *)

    (** {1 Iterators} *)

    val to_seq_from : elt -> t -> elt Seq.t
    (** [to_seq_from x s] iterates on a subset of the elements of [s]
        in ascending order, from [x] or above.
        @since 4.07 *)

    val to_seq : t -> elt Seq.t
    (** Iterate on the whole set, in ascending order
        @since 4.07 *)

    val to_rev_seq : t -> elt Seq.t
    (** Iterate on the whole set, in descending order
        @since 4.12 *)

    val add_seq : elt Seq.t -> t -> t
    (** Add the given elements to the set, in order.
        @since 4.07 *)

    val of_seq : elt Seq.t -> t
    (** Build a set from the given bindings
        @since 4.07 *)
  end
(** Output signature of the functor {!Make}. *)

module Make (Ord : OrderedType) : S with type elt = Ord.t
(** Functor building an implementation of the set structure
   given a totally ordered type. *)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (**************************************************************************)
(*                                                                        *)
(*                                 OCaml                                  *)
(*                                                                        *)
(*             Xavier Leroy, projet Cristal, INRIA Rocquencourt           *)
(*                                                                        *)
(*   Copyright 1996 Institut National de Recherche en Informatique et     *)
(*     en Automatique.                                                    *)
(*                                                                        *)
(*   All rights reserved.  This file is distributed under the terms of    *)
(*   the GNU Lesser General Public License version 2.1, with the          *)
(*   special exception on linking described in the file LICENSE.          *)
(*                                                                        *)
(**************************************************************************)

type 'a t = { mutable c : 'a list; mutable len : int; }

exception Empty

let create () = { c = []; len = 0; }

let clear s = s.c <- []; s.len <- 0

let copy s = { c = s.c; len = s.len; }

let push x s = s.c <- x :: s.c; s.len <- s.len + 1

let pop s =
  match s.c with
  | hd::tl -> s.c <- tl; s.len <- s.len - 1; hd
  | []     -> raise Empty

let pop_opt s =
  match s.c with
  | hd::tl -> s.c <- tl; s.len <- s.len - 1; Some hd
  | []     -> None

let top s =
  match s.c with
  | hd::_ -> hd
  | []    -> raise Empty

let top_opt s =
  match s.c with
  | hd::_ -> Some hd
  | []    -> None

let is_empty s = (s.c = [])

let length s = s.len

let iter f s = List.iter f s.c

let fold f acc s = List.fold_left f acc s.c

(** {1 Iterators} *)

let to_seq s = List.to_seq s.c

let add_seq q i = Seq.iter (fun x -> push x q) i

let of_seq g =
  let s = create() in
  add_seq s g;
  s
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (**************************************************************************)
(*                                                                        *)
(*                                 OCaml                                  *)
(*                                                                        *)
(*             Xavier Leroy, projet Cristal, INRIA Rocquencourt           *)
(*                                                                        *)
(*   Copyright 1996 Institut National de Recherche en Informatique et     *)
(*     en Automatique.                                                    *)
(*                                                                        *)
(*   All rights reserved.  This file is distributed under the terms of    *)
(*   the GNU Lesser General Public License version 2.1, with the          *)
(*   special exception on linking described in the file LICENSE.          *)
(*                                                                        *)
(**************************************************************************)

(** Last-in first-out stacks.

   This module implements stacks (LIFOs), with in-place modification.
*)

type !'a t
(** The type of stacks containing elements of type ['a]. *)

exception Empty
(** Raised when {!Stack.pop} or {!Stack.top} is applied to an empty stack. *)


val create : unit -> 'a t
(** Return a new stack, initially empty. *)

val push : 'a -> 'a t -> unit
(** [push x s] adds the element [x] at the top of stack [s]. *)

val pop : 'a t -> 'a
(** [pop s] removes and returns the topmost element in stack [s],
   or raises {!Empty} if the stack is empty. *)

val pop_opt : 'a t -> 'a option
(** [pop_opt s] removes and returns the topmost element in stack [s],
   or returns [None] if the stack is empty.
   @since 4.08 *)

val top : 'a t -> 'a
(** [top s] returns the topmost element in stack [s],
   or raises {!Empty} if the stack is empty. *)

val top_opt : 'a t -> 'a option
(** [top_opt s] returns the topmost element in stack [s],
   or [None] if the stack is empty.
   @since 4.08 *)

val clear : 'a t -> unit
(** Discard all elements from a stack. *)

val copy : 'a t -> 'a t
(** Return a copy of the given stack. *)

val is_empty : 'a t -> bool
(** Return [true] if the given stack is empty, [false] otherwise. *)

val length : 'a t -> int
(** Return the number of elements in a stack. Time complexity O(1) *)

val iter : ('a -> unit) -> 'a t -> unit
(** [iter f s] applies [f] in turn to all elements of [s],
   from the element at the top of the stack to the element at the
   bottom of the stack. The stack itself is unchanged. *)

val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
(** [fold f accu s] is [(f (... (f (f accu x1) x2) ...) xn)]
    where [x1] is the top of the stack, [x2] the second element,
    and [xn] the bottom element. The stack is unchanged.
    @since 4.03 *)

(** {1 Stacks and Sequences} *)

val to_seq : 'a t -> 'a Seq.t
(** Iterate on the stack, top to bottom.
    It is safe to modify the stack during iteration.
    @since 4.07 *)

val add_seq : 'a t -> 'a Seq.t -> unit
(** Add the elements from the sequence on the top of the stack.
    @since 4.07 *)

val of_seq : 'a Seq.t -> 'a t
(** Create a stack from the sequence.
    @since 4.07 *)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (**************************************************************************)
(*                                                                        *)
(*                                 OCaml                                  *)
(*                                                                        *)
(*                Jacques Garrigue, Kyoto University RIMS                 *)
(*                                                                        *)
(*   Copyright 2001 Institut National de Recherche en Informatique et     *)
(*     en Automatique.                                                    *)
(*                                                                        *)
(*   All rights reserved.  This file is distributed under the terms of    *)
(*   the GNU Lesser General Public License version 2.1, with the          *)
(*   special exception on linking described in the file LICENSE.          *)
(*                                                                        *)
(**************************************************************************)

(* Module [StdLabels]: meta-module for labelled libraries *)

module Array = ArrayLabels

module List = ListLabels

module String = StringLabels

module Bytes = BytesLabels
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (**************************************************************************)
(*                                                                        *)
(*                                 OCaml                                  *)
(*                                                                        *)
(*                Jacques Garrigue, Kyoto University RIMS                 *)
(*                                                                        *)
(*   Copyright 2001 Institut National de Recherche en Informatique et     *)
(*     en Automatique.                                                    *)
(*                                                                        *)
(*   All rights reserved.  This file is distributed under the terms of    *)
(*   the GNU Lesser General Public License version 2.1, with the          *)
(*   special exception on linking described in the file LICENSE.          *)
(*                                                                        *)
(**************************************************************************)

(** Standard labeled libraries.

   This meta-module provides versions of the {!Array}, {!Bytes},
   {!List} and {!String} modules where function arguments are
   systematically labeled.  It is intended to be opened at the top of
   source files, as shown below.

   {[
     open StdLabels

     let to_upper = String.map ~f:Char.uppercase_ascii
     let seq len = List.init ~f:(function i -> i) ~len
     let everything = Array.create_matrix ~dimx:42 ~dimy:42 42
   ]}

*)

module Array = ArrayLabels
module Bytes = BytesLabels
module List = ListLabels
module String = StringLabels
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Caml1999I030            (Std_exit@   f      9   .(Std_exit0.i[5䑹V&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@            @@                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Caml1999O030  c   8       f   !   :   9         D  F  7    , X(Std_exit&_none_@@ AA"??A@@@@@@@@@@@  , T	+std_exit.mlRR@$unitF@@ @A@*floatarrayQ  8 @@@A@@@@@5@@@5extension_constructorP  8 @@@A@@@@@9@@@#intA  8 @@@A@@@@@=@A@$charB  8 @@@A@@@@@A@A@&stringO  8 @@@A@@@@@E@@@%floatD  8 @@@A@@@@@I@@@$boolE  8 @@%false^@@S@$true_@@Y@@@A@@@@@Z@A@$unitF  8 @@"()`@@d@@@A@@@@@e@A@
#exnG  8 @@AA@@@@@i@@@%arrayH  8 @ @O@A@A@ @@@@@r@@@$listI  8 @ @P@A"[]a@@@"::b@@ @Q@@@
@@A@Y@@@@@@@@&optionJ  8 @ @S@A$Nonec@@@$Somed@@@@@A@Y@@@@@@@@&lazy_tN  8 @ @U@A@A@Y@@@@@@@@)nativeintK  8 @@@A@@@@@@@@%int32L  8 @@@A@@@@@@@@%int64M  8 @@@A@@@@@@@@:Undefined_recursive_module]    Z@@@ @J@@ @@@ @V@@AϠ=ocaml.warn_on_literal_patternӐ@@.Assert_failure\    @@ @X@@Aߠ@
0Division_by_zeroY    '@@@A砰@+End_of_fileX    /@@@A @)Sys_errorW    7@3@@A)(@.Sys_blocked_io[    @@@@A 10@)Not_foundV    H@@@A98@'FailureU    P@L@@ABA@0Invalid_argumentT    Y@U@@AKJ@.Stack_overflowZ    b@@@A"S%R%@-Out_of_memoryS    j@@@A*[-Z-@-Match_failureR    r@qmn@ @c@@A8i;h;@
%bytesC  8 @@@A@@@@@?@@@&Stdlib?>@@@            (./stdlib@         ^   R  ( (Std_exitP`&StdlibH
\@&Stdlib0-&fºnr39tߠ0.i[5䑹V8CamlinternalFormatBasics0ĵ'(jd@@@@pw                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Caml1999I030            (Std_exit@   f      9   .(Std_exit0.i[5䑹V&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@            @@Caml1999T030    	  	C  f  4 (Std_exit@@+std_exit.mlRR@@$unitF@@ @A@  0 @@@@@@*floatarrayQ  8 @@@A@@@@@&_none_@@ A@@@5extension_constructorP  8 @@@A@@@@@@@@#intA  8 @@@A@@@@@@A@$charB  8 @@@A@@@@@@A@&stringO  8 @@@A@@@@@@@@%floatD  8 @@@A@@@@@@@@$boolE  8 @@%false^@@!@$true_@@'@@@A@@@@@(@A@$unitF  8 @@"()`@@2@@@A@@@@@3@A@
#exnG  8 @@AA@@@@@7@@@%arrayH  8 @ @O@A@A@ @@@@@@@@@$listI  8 @ @P@A"[]a@@M@"::b@@ @Q@@Z@
@@A@Y@@@@@]@@@&optionJ  8 @ @S@A$Nonec@@j@$Somed@@q@@@A@Y@@@@@t@@@&lazy_tN  8 @ @U@A@A@Y@@@@@}@@@)nativeintK  8 @@@A@@@@@@@@%int32L  8 @@@A@@@@@@@@%int64M  8 @@@A@@@@@@@@:Undefined_recursive_module]    Z@@@ @J@@ @@@ @V@@A=ocaml.warn_on_literal_pattern@@.Assert_failure\    @@ @X@@A@
0Division_by_zeroY    '@@@A@+End_of_fileX    /@@@A @)Sys_errorW    7@3@@AƠ)(@.Sys_blocked_io[    @@@@AΠ10@)Not_foundV    H@@@A֠98@'FailureU    P@L@@AߠBA@0Invalid_argumentT    Y@U@@A蠰KJ@.Stack_overflowZ    b@@@A𠰠SR@-Out_of_memoryS    j@@@A[Z@-Match_failureR    r@qmn@ @c@@Ai	h	@
%bytesC  8 @@@A@@@@@
@@@&Stdlib@@@డ*do_at_exitIRJR@@I@@ @M@@ @@ @@*stdlib.mli\  !  !\  !  >@@&Stdlib @@@@@A@\@@A@@A@Y@@ภ"()#mR@  < @@ @N@@@@A@A@AE@@@+@@)@@B@ B@$o@@2@@vp@@|R@@@s@@s@	H************************************************************************A@@A@ L@	H                                                                        B M MB M @	H                                 OCaml                                  C  C  @	H                                                                        D  D 3@	H             Xavier Leroy, projet Cristal, INRIA Rocquencourt           E44E4@	H                                                                        FF@	H   Copyright 1996 Institut National de Recherche en Informatique et     GG@	H     en Automatique.                                                    HHg@	H                                                                        IhhIh@	H   All rights reserved.  This file is distributed under the terms of    JJ@	H   the GNU Lesser General Public License version 2.1, with the          KKN@	H   special exception on linking described in the file LICENSE.          LOOLO@	H                                                                        MM@	H************************************************************************NN5@	H Ensure that [at_exit] functions are called at the end of every program P77P7@@  @ +../ocamlopt0-strict-sequence(-absname"-w8+a-4-9-41-42-44-45-48-70"-g+-warn-error"+A*-bin-annot)-nostdlib*-principal,-safe-string/-strict-formats2-function-sections"-c(./stdlib @0)ŊD<1u贴p}㠠8CamlinternalFormatBasics0ĵ'(jdǠ0.i[5䑹V&Stdlib0-&fºnr39t@0.i[5䑹VA                                                                                                                                 Caml1999Y030         \   N  ( (Std_exit@&Stdlib0-&fºnr39tߠ	0.i[5䑹V8CamlinternalFormatBasics0ĵ'(jd@&Stdlib0~tV*e @@@@@<8+hS	"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (**************************************************************************)
(*                                                                        *)
(*                                 OCaml                                  *)
(*                                                                        *)
(*             Xavier Leroy, projet Cristal, INRIA Rocquencourt           *)
(*                                                                        *)
(*   Copyright 1996 Institut National de Recherche en Informatique et     *)
(*     en Automatique.                                                    *)
(*                                                                        *)
(*   All rights reserved.  This file is distributed under the terms of    *)
(*   the GNU Lesser General Public License version 2.1, with the          *)
(*   special exception on linking described in the file LICENSE.          *)
(*                                                                        *)
(**************************************************************************)

(* Ensure that [at_exit] functions are called at the end of every program *)

let _ = do_at_exit()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ELF          >                              @     @                                                               9  @a#    P  stdlib.ml std_exit.ml   Std_exit    Stdlib.do_at_exit                  H   H    H8  HH;׸   Hs    H   
       std_exit.ml    camlinternalAtomic.ml    stdlib.ml      	        
t<< C                                            E                 %  . ?I  ;     ,                     )                       std_exit.ml ./stdlib GNU AS 2.40 camlStd_exit__entry           zR x            )    DdA                                                                                                                       
                                                                                                        8                     Q                    ^                    u             )                                                       	                                           (       h        caml_negf_mask caml_absf_mask camlStd_exit__data_begin camlStd_exit__code_begin camlStd_exit camlStd_exit__gc_roots camlStd_exit__entry _GLOBAL_OFFSET_TABLE_ camlStdlib camlStd_exit__code_end camlStd_exit__data_end camlStd_exit__frametable                             0                           *      W                           
                     
                                                )               
              $       
             (       
             /       
      !       5          
           =          
   )              
                                                          .symtab .strtab .shstrtab .text .rela.data .bss .rodata.cst16 .text.caml.camlStd_exit__code_begin .rela.text.caml.camlStd_exit__entry .text.caml.camlStd_exit__code_end .note.GNU-stack .rela.debug_line .rela.debug_info .debug_abbrev .rela.debug_aranges .debug_str .rela.eh_frame                                                                                       @                                      &                     @                                     !      @               `      0                           ,                                                           1                                                          ?                                                           h                            )                              c      @                                                                                                                                                                                                 w                                    @                                                                            G                                    @                               
                                             (                                                           0                                    @                     0                                 0               0      5                             
                    h      8                                   @                                                                                     	                 	                      h                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             Caml1999Y030    W      ( &Stdlib@,Stdlib__Weak@,Stdlib__Unit@-Stdlib__Uchar@+Stdlib__Sys@4Stdlib__StringLabels@.Stdlib__String@.Stdlib__Stream@1Stdlib__StdLabels@-Stdlib__Stack@+Stdlib__Set@+Stdlib__Seq@-Stdlib__Scanf@.Stdlib__Result@.Stdlib__Random@-Stdlib__Queue@.Stdlib__Printf@0Stdlib__Printexc@2Stdlib__Pervasives@/Stdlib__Parsing@.Stdlib__Option@*Stdlib__Oo@+Stdlib__Obj@1Stdlib__Nativeint@2Stdlib__MoreLabels@/Stdlib__Marshal@+Stdlib__Map@2Stdlib__ListLabels@,Stdlib__List@.Stdlib__Lexing@,Stdlib__Lazy@-Stdlib__Int64@-Stdlib__Int32@+Stdlib__Int@/Stdlib__Hashtbl@.Stdlib__Genlex@*Stdlib__Gc@+Stdlib__Fun@.Stdlib__Format@-Stdlib__Float@0Stdlib__Filename@1Stdlib__Ephemeron@.Stdlib__Either@.Stdlib__Digest@/Stdlib__Complex@,Stdlib__Char@0Stdlib__Callback@3Stdlib__BytesLabels@-Stdlib__Bytes@.Stdlib__Buffer@,Stdlib__Bool@0Stdlib__Bigarray@.Stdlib__Atomic@3Stdlib__ArrayLabels@-Stdlib__Array@+Stdlib__Arg@0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jdǠ2CamlinternalAtomic0zo{I;@8CamlinternalFormatBasics0=TBAQ 2CamlinternalAtomic0uJ:@wh@DCB@@@  9camlStdlib__invalid_arg_9AA@A@6camlStdlib__failwith_6AA@A@-camlStdlib__3+Stdlib.Exit@*camlStdlibCDEFGHIJ	K
LMN2camlStdlib__min_43BA@A@2camlStdlib__max_47BA@A@2camlStdlib__abs_67AA!x E@E@@    )stdlib.ml dOU,, dA*Stdlib.abs0Stdlib.abs.(fun)@D@    
 dbd,, d	@A@?       3camlStdlib__lnot_73AA!x K@J @     jMX jA+Stdlib.lnot1Stdlib.lnot.(fun)@A@HUIVJWKXLYMZ1camlStdlib__^_140BA@A@;camlStdlib__char_of_int_149AA@A@>camlStdlib__string_of_bool_167AA!b @.camlStdlib__11$true.camlStdlib__12%falseA@	"camlStdlib__bool_of_string_opt_173AA%param @E@%false.camlStdlib__14@@@$true.camlStdlib__15@A@@E@@A@>camlStdlib__bool_of_string_170AA@A@=camlStdlib__string_of_int_176AA@A@	!camlStdlib__int_of_string_opt_180AA@A@?camlStdlib__string_of_float_190AA@A@	#camlStdlib__float_of_string_opt_194AA@A@1camlStdlib__@_197BA@A@efg:camlStdlib__print_char_350AA@A@<camlStdlib__print_string_353AA!sc@=camlStdlib__output_string_249f*camlStdlib@@@@
@    UkBBA3Stdlib.print_string9Stdlib.print_string.(fun)@A@;camlStdlib__print_bytes_356AA!sf@<camlStdlib__output_bytes_245f*camlStdlib@@@@
@    TiCCA2Stdlib.print_bytes8Stdlib.print_bytes.(fun)@A@9camlStdlib__print_int_359AA!ii@2f*camlStdlib@@@@X@    gxCCCCA0Stdlib.print_int6Stdlib.print_int.(fun)@@    RxCCCC@A@;camlStdlib__print_float_362AA!fl@Nf*camlStdlib@@@@n@    i|C|C|A2Stdlib.print_float8Stdlib.print_float.(fun)@@    T|C|C|@A@=camlStdlib__print_endline_365AA@A@=camlStdlib__print_newline_368AA@A@:camlStdlib__prerr_char_371AA@A@<camlStdlib__prerr_string_374AA!sx@sg*camlStdlib@@@@@    	UkDDA3Stdlib.prerr_string9Stdlib.prerr_string.(fun)@A@;camlStdlib__prerr_bytes_377AA!s{@rg*camlStdlib@@@@@    !TiDDA2Stdlib.prerr_bytes8Stdlib.prerr_bytes.(fun)@A@9camlStdlib__prerr_int_380AA!i~@g*camlStdlib@@@@ɠ@    ;gxDDA0Stdlib.prerr_int6Stdlib.prerr_int.(fun)@@    @RxDD@A@;camlStdlib__prerr_float_383AA!f@g*camlStdlib@@@@ߠ@    Wi|E.E.A2Stdlib.prerr_float8Stdlib.prerr_float.(fun)@@    \T|E.E.@A@=camlStdlib__prerr_endline_386AA@A@=camlStdlib__prerr_newline_389AA@A@9camlStdlib__read_line_392AA@A@<camlStdlib__read_int_opt_398AA @@@    ugtFFA3Stdlib.read_int_opt9Stdlib.read_int_opt.(fun)@@    zVtFF@A@8camlStdlib__read_int_395AA@A@>camlStdlib__read_float_opt_404AA8@$@@     kxFF A5Stdlib.read_float_opt;Stdlib.read_float_opt.(fun)@@     XxFF @A@:camlStdlib__read_float_401AA@A@8camlStdlib__open_out_227AA$name @<camlStdlib__open_out_gen_221.camlStdlib__23@A.camlStdlib__22@C.camlStdlib__21@D.camlStdlib__20@G@@@@@(@    PB J.Y.YPA/Stdlib.open_out5Stdlib.open_out.(fun)@A@<camlStdlib__open_out_bin_230AA$name @4.camlStdlib__27@A.camlStdlib__26@C.camlStdlib__25@D.camlStdlib__24@F@@@@@'@    SB L..SA3Stdlib.open_out_bin9Stdlib.open_out_bin.(fun)@A@_CA@A@3camlStdlib__fun_886AA$prim>@-caml_ml_flushAA @@@
@@A@9camlStdlib__flush_all_235AA@A@3camlStdlib__fun_884BA@?@3caml_ml_output_charBA@@@@@@A@BA@A@BA@A@6camlStdlib__output_253DA@A@	 camlStdlib__output_substring_259DA@A@3camlStdlib__fun_882BA3B6A@3caml_ml_output_charBA5@@@@@@A@3camlStdlib__fun_880BAHDKC@2caml_ml_output_intBAJ@@@@@@A@<camlStdlib__output_value_268BA@A@3camlStdlib__fun_878BA`FcE@0caml_ml_seek_outBAb@@@@@@A@3camlStdlib__fun_876AAuG@/caml_ml_pos_outAAt@@@@@A@3camlStdlib__fun_874AAH@4caml_ml_channel_sizeAA@@@@@A@9camlStdlib__close_out_276AA@A@?camlStdlib__close_out_noerr_279AA@A@3camlStdlib__fun_872BAJI@7caml_ml_set_binary_modeBA@@@@@@A@7camlStdlib__open_in_290AA$name$@;camlStdlib__open_in_gen_284.camlStdlib__30@@	@G@@@@@    Bm88A.Stdlib.open_in4Stdlib.open_in.(fun)@A@;camlStdlib__open_in_bin_293AA$name'@%.camlStdlib__31@@@F@@@@@    Bo8c8cA2Stdlib.open_in_bin8Stdlib.open_in_bin.(fun)@A@ACA@A@3camlStdlib__fun_870AAK@2caml_ml_input_charAA@@@@@A@:camlStdlib__input_line_322AA@A@5camlStdlib__input_298DA@A@<camlStdlib__really_input_310DA@A@	#camlStdlib__really_input_string_316BA@A@3camlStdlib__fun_868AAL@2caml_ml_input_charAA@@@@@A@3camlStdlib__fun_866AA#M@1caml_ml_input_intAA"@@@@@A@3camlStdlib__fun_864AA2N@0caml_input_valueAA1@@@@@A@3camlStdlib__fun_862BAAPDO@/caml_ml_seek_inBAC@@@@@@A@3camlStdlib__fun_860AAVQ@.caml_ml_pos_inAAU@@@@@A@3camlStdlib__fun_858AAeR@4caml_ml_channel_sizeAAd@@@@@A@3camlStdlib__fun_856AAtS@5caml_ml_close_channelAAs@@@@@A@>camlStdlib__close_in_noerr_346AA@A@3camlStdlib__fun_854BAUT@7caml_ml_set_binary_modeBA@@@@@@A@3camlStdlib__fun_957BA76@3caml_ml_seek_out_64BA@@@@@    @GHIB
B,Stdlib.(fun)@A@3camlStdlib__fun_959AA8@2caml_ml_pos_out_64AA@@@@    @GHIB
@A@3camlStdlib__fun_961AA9@7caml_ml_channel_size_64AAƠ@@@@    @GHIB
$@A@3camlStdlib__fun_963BA;:@2caml_ml_seek_in_64BAڠ@@@@@    @GHIB
;@A@3camlStdlib__fun_965AA<@1caml_ml_pos_in_64AA@@@@    @GHIB
L@A@3camlStdlib__fun_967AA =@7caml_ml_channel_size_64AA@@@@    @GHIB
]@A@	 camlStdlib__string_of_format_438AA@A@    UiJJA7Stdlib.string_of_format=Stdlib.string_of_format.(fun)@A@2camlStdlib__^^_444BA@A@@4camlStdlib__exit_476AA@A@7camlStdlib__at_exit_455AA@A@	!camlStdlib__valid_float_lexem_184AA@A@	#camlStdlib__unsafe_really_input_304DA@A@:camlStdlib__do_at_exit_473AA@@@#argӑ@@@ҹ g*camlStdlib@@@@@@    O6T}MM6A1Stdlib.do_at_exit7Stdlib.do_at_exit.(fun)    5camlinternalAtomic.ml\LO\A6CamlinternalAtomic.get<CamlinternalAtomic.get.(fun)@@    \6T}MM6
@A@ g@~tV*e                               Caml1999I030    <    b+Stdlib__Arg$spec u  8 @@$Unit R@$unitF@@ @d@@ @e@ @f@@'arg.mli K
3
5 K
3
M@@A$Bool S@$boolE@@ @a@@ @b@ @c@@ L
~
 L
~
@@4B#Set T&Stdlib#ref@@ @_@@ @`@@. M

/ M

@@KC%Clear U#ref0@@ @]@@ @^@@B N
C N @@_D&String V@&stringO@@ @Z^@@ @[@ @\@@X OLNY OLj@@uE*Set_string WA#ref@@ @X@@ @Y@@l Pm P@@F#Int X@#intA@@ @U@@ @V@ @W@@ Q Q@@G'Set_int Yk#ref@@ @S@@ @T@@ R79 R7M@@H%Float Z@%floatD@@ @P@@ @Q@ @R@@ S S@@I)Set_float [#ref@@ @N@@ @O@@ T T@@J%Tuple \$listI@@ @L@@ @M@@ U! U5@@K&Symbol ]@@ @J@@ @K@@@ @G@@ @H@ @I@@ W W@@L$Rest ^@@@ @D
@@ @E@ @F@@ ZZ\ ZZv@@$M(Rest_all _@I@@ @@@@ @A&@@ @B@ @C@@  \! \@@=N&Expand `@@@ @<%arrayH@@ @=@@ @>@ @?@@; _< _@@XO@@A@@@@@? J
'
'@@@@[@A@#key v  8 @@@A@@ @g@@@@L i

M i
@@@@iPA@#doc w  8 @@@A@@ @h@@@@Z j[ j-@@@@wQA@)usage_msg x  8 @@@A@@ @i@@@@h k..i k.E@@@@RA@(anon_fun y  8 @@@A@&@@ @j@@ @k@ @l@@@@| lFF} lFf@@@@SA@%parse z@M@@ @o@@ @nH@@ @m@ @p@@ @q@3@@ @r@G@@ @s@@ @t@ @u@ @v@ @w@ nhh ot@@T@-parse_dynamic {@#ref5@@ @z@@ @y4@@ @x@ @{@@ @|@@ @}@4@@ @~@3@@ @@@ @ @ @ @ @ @ @ @  E@@U@*parse_argv |'current&optionJ#ref~@@ @ @@ @ @@ @ @Π@@ @ @@ @ @?@@ @ D@@ @ @@ @ @ @ @@ @ @@@ @ @@@ @ 0@@ @ @ @ @ @ @ @ @ @ @ @ @* +  @@GV@2parse_argv_dynamic }'currentL#ref@@ @ @@ @ @@ @ @@@ @ @@ @ @1#ref@@ @ @@ @ @@ @ @ @ @@ @ @@ @ @@@ @ @$@@ @ @@ @ @ @ @ @ @ @ @ @ @ @ @z --{ j@@W@=parse_and_expand_argv_dynamic ~@d#ref@@ @ @@ @ @p#reffL@@ @ @@ @ @@ @ @#refݠ @@ @ @@ @ @@ @ @ @ @@ @ @@ @ @@@ @ @t@@ @ @@ @ @ @ @ @ @ @ @ @ @ @ @  W W   @@X@,parse_expand @N@@ @ @@ @ M@@ @ @ @ @@ @ @L@@ @ @K@@ @ @@ @ @ @ @ @ @ @ @ !! !!@@Y@ $Help     #exnG@@@ @ @@A&_none_@@ A@%ZB@ #Bad     @@@ @ @@A@1[B@%usage @U@@ @ ˠZ@@ @ ʠ@@ @ @ @ @@ @ @@@ @ A@@ @ @ @ @ @ @; ##< ##@@X\@,usage_string @|@@ @ Ԡ@@ @ Ӡ@@ @ @ @ @@ @ @@@ @ @@ @ @ @ @ @ @b $$c $%2@@]@%align %limit@@ @ @@ @ @@@ @ ߠ@@ @ ޠ@@ @ @ @ @@ @  @@ @ @@ @ @@ @ @ @ @@ @ @ @ @ @ @ %% %%@@^@'current #ref5@@ @ @@ @ @ '' ''@@_@(read_arg @o@@ @ w@@ @ @@ @ @ @ @ ).). ).)R@@`@)read_arg0 @@@ @ @@ @ @@ @ @ @ @ )) ))@@a@)write_arg @@@ @ @à@@ @ @@ @ @@ @ @ @ @ @ @  *g*g *g*@@b@*write_arg0 @@@ @ @@@ @ @@ @ $@@ @ @ @ @ @ @ +o+o +o+@@;c@@   i      9   .+Stdlib__Arg0@)6:
Z$o4*&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@            @@                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Caml1999Y030  
    F    ( +Stdlib__Arg@-Stdlib__Uchar0o9us:2[]+Stdlib__Sys0wg1XƮ"~7.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk.Stdlib__Printf0pJUX빃Ύ,Stdlib__List0U#r&L+Stdlib__Int0ʬ<xyd.Stdlib__Either0$_ʩ<.Stdlib__Buffer0ok
Vj-Stdlib__Array0XUJө
	ƿ860@)6:
Z$o4*&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@;0:eW -b:U.Stdlib__String0W\'"IĒ.Stdlib__Printf0TF	zhrj,Stdlib__List0!?$JOjĠ+Stdlib__Int0W0F*3濠.Stdlib__Buffer0Cr`M-i-Stdlib__Array0Hw
@&Stdlib0~tV*e @DFECB@DCB@@   :camlStdlib__Arg__parse_532CA@A@	"camlStdlib__Arg__parse_dynamic_621CA@A@?camlStdlib__Arg__parse_argv_523EA%*opt*
$argv(speclist'anonfun&errmsg@@@'current@@    &arg.ml&Y`))&A6Stdlib__Arg.parse_argv<Stdlib__Arg.parse_argv.(fun)@K/camlStdlib__Arg@@@@	&camlStdlib__Arg__parse_argv_inner_1216*(&$@@A@	'camlStdlib__Arg__parse_argv_dynamic_514EA;$argv(speclist'anonfun	&errmsg
@@@'current@@    :!ah((!A>Stdlib__Arg.parse_argv_dynamic	$Stdlib__Arg.parse_argv_dynamic.(fun)@K/camlStdlib__Arg@@@@	.camlStdlib__Arg__parse_argv_dynamic_inner_1208)'%#@@A@	2camlStdlib__Arg__parse_and_expand_argv_dynamic_507EA'current$argv(speclist'anonfun &errmsg@	6camlStdlib__Arg__parse_and_expand_argv_dynamic_aux_379A@    yB M((A	)Stdlib__Arg.parse_and_expand_argv_dynamic	/Stdlib__Arg.parse_and_expand_argv_dynamic.(fun)@A@	!camlStdlib__Arg__parse_expand_628CA@A@2camlStdlib__Arg__2/Stdlib.Arg.Help@2camlStdlib__Arg__1.Stdlib.Arg.Bad@:camlStdlib__Arg__usage_368BA@A@	!camlStdlib__Arg__usage_string_363BA@A@:camlStdlib__Arg__align_706BAĠ(speclist@@B%limitſ@@    uRY2E2EuA1Stdlib__Arg.align7Stdlib__Arg.align.(fun)@?	!camlStdlib__Arg__align_inner_1272@@A@/camlStdlib__ArgK9camlStdlib__Arg__fun_1303A@#arg#env@=camlStdlib__Arg__read_aux_719B	@@C@@@    Oa55A4Stdlib__Arg.read_arg:Stdlib__Arg.read_arg.(fun)@A@9camlStdlib__Arg__fun_1310A@  @B@@C@@@    Pe55A5Stdlib__Arg.read_arg0;Stdlib__Arg.read_arg0.(fun)@A@9camlStdlib__Arg__fun_1329B@=.@/?3@>camlStdlib__Arg__write_aux_735C@@@    P^66A5Stdlib__Arg.write_arg;Stdlib__Arg.write_arg.(fun)@A@9camlStdlib__Arg__fun_1336B@[5^6]:@C@@@    /Qa66A6Stdlib__Arg.write_arg0<Stdlib__Arg.write_arg0.(fun)@A@2camlStdlib__Arg__3/Stdlib.Arg.Stop@;camlStdlib__Arg__assoc3_122BA@A@:camlStdlib__Arg__split_128AA@A@@	!camlStdlib__Arg__make_symlist_205DA@A@?camlStdlib__Arg__print_spec_279BA@A@	 camlStdlib__Arg__help_action_350AA@A@=camlStdlib__Arg__add_help_353AA@A@<camlStdlib__Arg__usage_b_358CA@A@	'camlStdlib__Arg__bool_of_string_opt_373AA@A@	&camlStdlib__Arg__int_of_string_opt_375AA@A@	(camlStdlib__Arg__float_of_string_opt_377AA@A@FA@A@	 camlStdlib__Arg__second_word_638AA@A@	 camlStdlib__Arg__max_arg_len_646BA@A@	(camlStdlib__Arg__replace_leading_tab_683AA@A@	 camlStdlib__Arg__add_padding_688BA@A@<camlStdlib__Arg__trim_cr_715AA@A@CA@A@iCA@A@@hD7s{ rOF                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         # !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
# This file is machine-generated by lib/unicore/mktables from the Unicode
# database, Version 14.0.0.  Any changes made here will be lost!

# !!!!!!!   INTERNAL PERL USE ONLY   !!!!!!!
# This file is for internal use by core Perl only.  The format and even the
# name or existence of this file are subject to change without notice.  Don't
# use it directly.  Use Unicode::UCD to access the Unicode character data
# base.


return <<'END';
A0		<noBreak> 0020
A8		<compat> 0020 0308
AA		<super> 0061
AF		<compat> 0020 0304
B2		<super> 0032
B3		<super> 0033
B4		<compat> 0020 0301
B5		<compat> 03BC
B8		<compat> 0020 0327
B9		<super> 0031
BA		<super> 006F
BC		<fraction> 0031 2044 0034
BD		<fraction> 0031 2044 0032
BE		<fraction> 0033 2044 0034
C0		0041 0300
C1		0041 0301
C2		0041 0302
C3		0041 0303
C4		0041 0308
C5		0041 030A
C7		0043 0327
C8		0045 0300
C9		0045 0301
CA		0045 0302
CB		0045 0308
CC		0049 0300
CD		0049 0301
CE		0049 0302
CF		0049 0308
D1		004E 0303
D2		004F 0300
D3		004F 0301
D4		004F 0302
D5		004F 0303
D6		004F 0308
D9		0055 0300
DA		0055 0301
DB		0055 0302
DC		0055 0308
DD		0059 0301
E0		0061 0300
E1		0061 0301
E2		0061 0302
E3		0061 0303
E4		0061 0308
E5		0061 030A
E7		0063 0327
E8		0065 0300
E9		0065 0301
EA		0065 0302
EB		0065 0308
EC		0069 0300
ED		0069 0301
EE		0069 0302
EF		0069 0308
F1		006E 0303
F2		006F 0300
F3		006F 0301
F4		006F 0302
F5		006F 0303
F6		006F 0308
F9		0075 0300
FA		0075 0301
FB		0075 0302
FC		0075 0308
FD		0079 0301
FF		0079 0308
100		0041 0304
101		0061 0304
102		0041 0306
103		0061 0306
104		0041 0328
105		0061 0328
106		0043 0301
107		0063 0301
108		0043 0302
109		0063 0302
10A		0043 0307
10B		0063 0307
10C		0043 030C
10D		0063 030C
10E		0044 030C
10F		0064 030C
112		0045 0304
113		0065 0304
114		0045 0306
115		0065 0306
116		0045 0307
117		0065 0307
118		0045 0328
119		0065 0328
11A		0045 030C
11B		0065 030C
11C		0047 0302
11D		0067 0302
11E		0047 0306
11F		0067 0306
120		0047 0307
121		0067 0307
122		0047 0327
123		0067 0327
124		0048 0302
125		0068 0302
128		0049 0303
129		0069 0303
12A		0049 0304
12B		0069 0304
12C		0049 0306
12D		0069 0306
12E		0049 0328
12F		0069 0328
130		0049 0307
132		<compat> 0049 004A
133		<compat> 0069 006A
134		004A 0302
135		006A 0302
136		004B 0327
137		006B 0327
139		004C 0301
13A		006C 0301
13B		004C 0327
13C		006C 0327
13D		004C 030C
13E		006C 030C
13F		<compat> 004C 00B7
140		<compat> 006C 00B7
143		004E 0301
144		006E 0301
145		004E 0327
146		006E 0327
147		004E 030C
148		006E 030C
149		<compat> 02BC 006E
14C		004F 0304
14D		006F 0304
14E		004F 0306
14F		006F 0306
150		004F 030B
151		006F 030B
154		0052 0301
155		0072 0301
156		0052 0327
157		0072 0327
158		0052 030C
159		0072 030C
15A		0053 0301
15B		0073 0301
15C		0053 0302
15D		0073 0302
15E		0053 0327
15F		0073 0327
160		0053 030C
161		0073 030C
162		0054 0327
163		0074 0327
164		0054 030C
165		0074 030C
168		0055 0303
169		0075 0303
16A		0055 0304
16B		0075 0304
16C		0055 0306
16D		0075 0306
16E		0055 030A
16F		0075 030A
170		0055 030B
171		0075 030B
172		0055 0328
173		0075 0328
174		0057 0302
175		0077 0302
176		0059 0302
177		0079 0302
178		0059 0308
179		005A 0301
17A		007A 0301
17B		005A 0307
17C		007A 0307
17D		005A 030C
17E		007A 030C
17F		<compat> 0073
1A0		004F 031B
1A1		006F 031B
1AF		0055 031B
1B0		0075 031B
1C4		<compat> 0044 017D
1C5		<compat> 0044 017E
1C6		<compat> 0064 017E
1C7		<compat> 004C 004A
1C8		<compat> 004C 006A
1C9		<compat> 006C 006A
1CA		<compat> 004E 004A
1CB		<compat> 004E 006A
1CC		<compat> 006E 006A
1CD		0041 030C
1CE		0061 030C
1CF		0049 030C
1D0		0069 030C
1D1		004F 030C
1D2		006F 030C
1D3		0055 030C
1D4		0075 030C
1D5		00DC 0304
1D6		00FC 0304
1D7		00DC 0301
1D8		00FC 0301
1D9		00DC 030C
1DA		00FC 030C
1DB		00DC 0300
1DC		00FC 0300
1DE		00C4 0304
1DF		00E4 0304
1E0		0226 0304
1E1		0227 0304
1E2		00C6 0304
1E3		00E6 0304
1E6		0047 030C
1E7		0067 030C
1E8		004B 030C
1E9		006B 030C
1EA		004F 0328
1EB		006F 0328
1EC		01EA 0304
1ED		01EB 0304
1EE		01B7 030C
1EF		0292 030C
1F0		006A 030C
1F1		<compat> 0044 005A
1F2		<compat> 0044 007A
1F3		<compat> 0064 007A
1F4		0047 0301
1F5		0067 0301
1F8		004E 0300
1F9		006E 0300
1FA		00C5 0301
1FB		00E5 0301
1FC		00C6 0301
1FD		00E6 0301
1FE		00D8 0301
1FF		00F8 0301
200		0041 030F
201		0061 030F
202		0041 0311
203		0061 0311
204		0045 030F
205		0065 030F
206		0045 0311
207		0065 0311
208		0049 030F
209		0069 030F
20A		0049 0311
20B		0069 0311
20C		004F 030F
20D		006F 030F
20E		004F 0311
20F		006F 0311
210		0052 030F
211		0072 030F
212		0052 0311
213		0072 0311
214		0055 030F
215		0075 030F
216		0055 0311
217		0075 0311
218		0053 0326
219		0073 0326
21A		0054 0326
21B		0074 0326
21E		0048 030C
21F		0068 030C
226		0041 0307
227		0061 0307
228		0045 0327
229		0065 0327
22A		00D6 0304
22B		00F6 0304
22C		00D5 0304
22D		00F5 0304
22E		004F 0307
22F		006F 0307
230		022E 0304
231		022F 0304
232		0059 0304
233		0079 0304
2B0		<super> 0068
2B1		<super> 0266
2B2		<super> 006A
2B3		<super> 0072
2B4		<super> 0279
2B5		<super> 027B
2B6		<super> 0281
2B7		<super> 0077
2B8		<super> 0079
2D8		<compat> 0020 0306
2D9		<compat> 0020 0307
2DA		<compat> 0020 030A
2DB		<compat> 0020 0328
2DC		<compat> 0020 0303
2DD		<compat> 0020 030B
2E0		<super> 0263
2E1		<super> 006C
2E2		<super> 0073
2E3		<super> 0078
2E4		<super> 0295
340		0300
341		0301
343		0313
344		0308 0301
374		02B9
37A		<compat> 0020 0345
37E		003B
384		<compat> 0020 0301
385		00A8 0301
386		0391 0301
387		00B7
388		0395 0301
389		0397 0301
38A		0399 0301
38C		039F 0301
38E		03A5 0301
38F		03A9 0301
390		03CA 0301
3AA		0399 0308
3AB		03A5 0308
3AC		03B1 0301
3AD		03B5 0301
3AE		03B7 0301
3AF		03B9 0301
3B0		03CB 0301
3CA		03B9 0308
3CB		03C5 0308
3CC		03BF 0301
3CD		03C5 0301
3CE		03C9 0301
3D0		<compat> 03B2
3D1		<compat> 03B8
3D2		<compat> 03A5
3D3		03D2 0301
3D4		03D2 0308
3D5		<compat> 03C6
3D6		<compat> 03C0
3F0		<compat> 03BA
3F1		<compat> 03C1
3F2		<compat> 03C2
3F4		<compat> 0398
3F5		<compat> 03B5
3F9		<compat> 03A3
400		0415 0300
401		0415 0308
403		0413 0301
407		0406 0308
40C		041A 0301
40D		0418 0300
40E		0423 0306
419		0418 0306
439		0438 0306
450		0435 0300
451		0435 0308
453		0433 0301
457		0456 0308
45C		043A 0301
45D		0438 0300
45E		0443 0306
476		0474 030F
477		0475 030F
4C1		0416 0306
4C2		0436 0306
4D0		0410 0306
4D1		0430 0306
4D2		0410 0308
4D3		0430 0308
4D6		0415 0306
4D7		0435 0306
4DA		04D8 0308
4DB		04D9 0308
4DC		0416 0308
4DD		0436 0308
4DE		0417 0308
4DF		0437 0308
4E2		0418 0304
4E3		0438 0304
4E4		0418 0308
4E5		0438 0308
4E6		041E 0308
4E7		043E 0308
4EA		04E8 0308
4EB		04E9 0308
4EC		042D 0308
4ED		044D 0308
4EE		0423 0304
4EF		0443 0304
4F0		0423 0308
4F1		0443 0308
4F2		0423 030B
4F3		0443 030B
4F4		0427 0308
4F5		0447 0308
4F8		042B 0308
4F9		044B 0308
587		<compat> 0565 0582
622		0627 0653
623		0627 0654
624		0648 0654
625		0627 0655
626		064A 0654
675		<compat> 0627 0674
676		<compat> 0648 0674
677		<compat> 06C7 0674
678		<compat> 064A 0674
6C0		06D5 0654
6C2		06C1 0654
6D3		06D2 0654
929		0928 093C
931		0930 093C
934		0933 093C
958		0915 093C
959		0916 093C
95A		0917 093C
95B		091C 093C
95C		0921 093C
95D		0922 093C
95E		092B 093C
95F		092F 093C
9CB		09C7 09BE
9CC		09C7 09D7
9DC		09A1 09BC
9DD		09A2 09BC
9DF		09AF 09BC
A33		0A32 0A3C
A36		0A38 0A3C
A59		0A16 0A3C
A5A		0A17 0A3C
A5B		0A1C 0A3C
A5E		0A2B 0A3C
B48		0B47 0B56
B4B		0B47 0B3E
B4C		0B47 0B57
B5C		0B21 0B3C
B5D		0B22 0B3C
B94		0B92 0BD7
BCA		0BC6 0BBE
BCB		0BC7 0BBE
BCC		0BC6 0BD7
C48		0C46 0C56
CC0		0CBF 0CD5
CC7		0CC6 0CD5
CC8		0CC6 0CD6
CCA		0CC6 0CC2
CCB		0CCA 0CD5
D4A		0D46 0D3E
D4B		0D47 0D3E
D4C		0D46 0D57
DDA		0DD9 0DCA
DDC		0DD9 0DCF
DDD		0DDC 0DCA
DDE		0DD9 0DDF
E33		<compat> 0E4D 0E32
EB3		<compat> 0ECD 0EB2
EDC		<compat> 0EAB 0E99
EDD		<compat> 0EAB 0EA1
F0C		<noBreak> 0F0B
F43		0F42 0FB7
F4D		0F4C 0FB7
F52		0F51 0FB7
F57		0F56 0FB7
F5C		0F5B 0FB7
F69		0F40 0FB5
F73		0F71 0F72
F75		0F71 0F74
F76		0FB2 0F80
F77		<compat> 0FB2 0F81
F78		0FB3 0F80
F79		<compat> 0FB3 0F81
F81		0F71 0F80
F93		0F92 0FB7
F9D		0F9C 0FB7
FA2		0FA1 0FB7
FA7		0FA6 0FB7
FAC		0FAB 0FB7
FB9		0F90 0FB5
1026		1025 102E
10FC		<super> 10DC
1B06		1B05 1B35
1B08		1B07 1B35
1B0A		1B09 1B35
1B0C		1B0B 1B35
1B0E		1B0D 1B35
1B12		1B11 1B35
1B3B		1B3A 1B35
1B3D		1B3C 1B35
1B40		1B3E 1B35
1B41		1B3F 1B35
1B43		1B42 1B35
1D2C		<super> 0041
1D2D		<super> 00C6
1D2E		<super> 0042
1D30		<super> 0044
1D31		<super> 0045
1D32		<super> 018E
1D33		<super> 0047
1D34		<super> 0048
1D35		<super> 0049
1D36		<super> 004A
1D37		<super> 004B
1D38		<super> 004C
1D39		<super> 004D
1D3A		<super> 004E
1D3C		<super> 004F
1D3D		<super> 0222
1D3E		<super> 0050
1D3F		<super> 0052
1D40		<super> 0054
1D41		<super> 0055
1D42		<super> 0057
1D43		<super> 0061
1D44		<super> 0250
1D45		<super> 0251
1D46		<super> 1D02
1D47		<super> 0062
1D48		<super> 0064
1D49		<super> 0065
1D4A		<super> 0259
1D4B		<super> 025B
1D4C		<super> 025C
1D4D		<super> 0067
1D4F		<super> 006B
1D50		<super> 006D
1D51		<super> 014B
1D52		<super> 006F
1D53		<super> 0254
1D54		<super> 1D16
1D55		<super> 1D17
1D56		<super> 0070
1D57		<super> 0074
1D58		<super> 0075
1D59		<super> 1D1D
1D5A		<super> 026F
1D5B		<super> 0076
1D5C		<super> 1D25
1D5D		<super> 03B2
1D5E		<super> 03B3
1D5F		<super> 03B4
1D60		<super> 03C6
1D61		<super> 03C7
1D62		<sub> 0069
1D63		<sub> 0072
1D64		<sub> 0075
1D65		<sub> 0076
1D66		<sub> 03B2
1D67		<sub> 03B3
1D68		<sub> 03C1
1D69		<sub> 03C6
1D6A		<sub> 03C7
1D78		<super> 043D
1D9B		<super> 0252
1D9C		<super> 0063
1D9D		<super> 0255
1D9E		<super> 00F0
1D9F		<super> 025C
1DA0		<super> 0066
1DA1		<super> 025F
1DA2		<super> 0261
1DA3		<super> 0265
1DA4		<super> 0268
1DA5		<super> 0269
1DA6		<super> 026A
1DA7		<super> 1D7B
1DA8		<super> 029D
1DA9		<super> 026D
1DAA		<super> 1D85
1DAB		<super> 029F
1DAC		<super> 0271
1DAD		<super> 0270
1DAE		<super> 0272
1DAF		<super> 0273
1DB0		<super> 0274
1DB1		<super> 0275
1DB2		<super> 0278
1DB3		<super> 0282
1DB4		<super> 0283
1DB5		<super> 01AB
1DB6		<super> 0289
1DB7		<super> 028A
1DB8		<super> 1D1C
1DB9		<super> 028B
1DBA		<super> 028C
1DBB		<super> 007A
1DBC		<super> 0290
1DBD		<super> 0291
1DBE		<super> 0292
1DBF		<super> 03B8
1E00		0041 0325
1E01		0061 0325
1E02		0042 0307
1E03		0062 0307
1E04		0042 0323
1E05		0062 0323
1E06		0042 0331
1E07		0062 0331
1E08		00C7 0301
1E09		00E7 0301
1E0A		0044 0307
1E0B		0064 0307
1E0C		0044 0323
1E0D		0064 0323
1E0E		0044 0331
1E0F		0064 0331
1E10		0044 0327
1E11		0064 0327
1E12		0044 032D
1E13		0064 032D
1E14		0112 0300
1E15		0113 0300
1E16		0112 0301
1E17		0113 0301
1E18		0045 032D
1E19		0065 032D
1E1A		0045 0330
1E1B		0065 0330
1E1C		0228 0306
1E1D		0229 0306
1E1E		0046 0307
1E1F		0066 0307
1E20		0047 0304
1E21		0067 0304
1E22		0048 0307
1E23		0068 0307
1E24		0048 0323
1E25		0068 0323
1E26		0048 0308
1E27		0068 0308
1E28		0048 0327
1E29		0068 0327
1E2A		0048 032E
1E2B		0068 032E
1E2C		0049 0330
1E2D		0069 0330
1E2E		00CF 0301
1E2F		00EF 0301
1E30		004B 0301
1E31		006B 0301
1E32		004B 0323
1E33		006B 0323
1E34		004B 0331
1E35		006B 0331
1E36		004C 0323
1E37		006C 0323
1E38		1E36 0304
1E39		1E37 0304
1E3A		004C 0331
1E3B		006C 0331
1E3C		004C 032D
1E3D		006C 032D
1E3E		004D 0301
1E3F		006D 0301
1E40		004D 0307
1E41		006D 0307
1E42		004D 0323
1E43		006D 0323
1E44		004E 0307
1E45		006E 0307
1E46		004E 0323
1E47		006E 0323
1E48		004E 0331
1E49		006E 0331
1E4A		004E 032D
1E4B		006E 032D
1E4C		00D5 0301
1E4D		00F5 0301
1E4E		00D5 0308
1E4F		00F5 0308
1E50		014C 0300
1E51		014D 0300
1E52		014C 0301
1E53		014D 0301
1E54		0050 0301
1E55		0070 0301
1E56		0050 0307
1E57		0070 0307
1E58		0052 0307
1E59		0072 0307
1E5A		0052 0323
1E5B		0072 0323
1E5C		1E5A 0304
1E5D		1E5B 0304
1E5E		0052 0331
1E5F		0072 0331
1E60		0053 0307
1E61		0073 0307
1E62		0053 0323
1E63		0073 0323
1E64		015A 0307
1E65		015B 0307
1E66		0160 0307
1E67		0161 0307
1E68		1E62 0307
1E69		1E63 0307
1E6A		0054 0307
1E6B		0074 0307
1E6C		0054 0323
1E6D		0074 0323
1E6E		0054 0331
1E6F		0074 0331
1E70		0054 032D
1E71		0074 032D
1E72		0055 0324
1E73		0075 0324
1E74		0055 0330
1E75		0075 0330
1E76		0055 032D
1E77		0075 032D
1E78		0168 0301
1E79		0169 0301
1E7A		016A 0308
1E7B		016B 0308
1E7C		0056 0303
1E7D		0076 0303
1E7E		0056 0323
1E7F		0076 0323
1E80		0057 0300
1E81		0077 0300
1E82		0057 0301
1E83		0077 0301
1E84		0057 0308
1E85		0077 0308
1E86		0057 0307
1E87		0077 0307
1E88		0057 0323
1E89		0077 0323
1E8A		0058 0307
1E8B		0078 0307
1E8C		0058 0308
1E8D		0078 0308
1E8E		0059 0307
1E8F		0079 0307
1E90		005A 0302
1E91		007A 0302
1E92		005A 0323
1E93		007A 0323
1E94		005A 0331
1E95		007A 0331
1E96		0068 0331
1E97		0074 0308
1E98		0077 030A
1E99		0079 030A
1E9A		<compat> 0061 02BE
1E9B		017F 0307
1EA0		0041 0323
1EA1		0061 0323
1EA2		0041 0309
1EA3		0061 0309
1EA4		00C2 0301
1EA5		00E2 0301
1EA6		00C2 0300
1EA7		00E2 0300
1EA8		00C2 0309
1EA9		00E2 0309
1EAA		00C2 0303
1EAB		00E2 0303
1EAC		1EA0 0302
1EAD		1EA1 0302
1EAE		0102 0301
1EAF		0103 0301
1EB0		0102 0300
1EB1		0103 0300
1EB2		0102 0309
1EB3		0103 0309
1EB4		0102 0303
1EB5		0103 0303
1EB6		1EA0 0306
1EB7		1EA1 0306
1EB8		0045 0323
1EB9		0065 0323
1EBA		0045 0309
1EBB		0065 0309
1EBC		0045 0303
1EBD		0065 0303
1EBE		00CA 0301
1EBF		00EA 0301
1EC0		00CA 0300
1EC1		00EA 0300
1EC2		00CA 0309
1EC3		00EA 0309
1EC4		00CA 0303
1EC5		00EA 0303
1EC6		1EB8 0302
1EC7		1EB9 0302
1EC8		0049 0309
1EC9		0069 0309
1ECA		0049 0323
1ECB		0069 0323
1ECC		004F 0323
1ECD		006F 0323
1ECE		004F 0309
1ECF		006F 0309
1ED0		00D4 0301
1ED1		00F4 0301
1ED2		00D4 0300
1ED3		00F4 0300
1ED4		00D4 0309
1ED5		00F4 0309
1ED6		00D4 0303
1ED7		00F4 0303
1ED8		1ECC 0302
1ED9		1ECD 0302
1EDA		01A0 0301
1EDB		01A1 0301
1EDC		01A0 0300
1EDD		01A1 0300
1EDE		01A0 0309
1EDF		01A1 0309
1EE0		01A0 0303
1EE1		01A1 0303
1EE2		01A0 0323
1EE3		01A1 0323
1EE4		0055 0323
1EE5		0075 0323
1EE6		0055 0309
1EE7		0075 0309
1EE8		01AF 0301
1EE9		01B0 0301
1EEA		01AF 0300
1EEB		01B0 0300
1EEC		01AF 0309
1EED		01B0 0309
1EEE		01AF 0303
1EEF		01B0 0303
1EF0		01AF 0323
1EF1		01B0 0323
1EF2		0059 0300
1EF3		0079 0300
1EF4		0059 0323
1EF5		0079 0323
1EF6		0059 0309
1EF7		0079 0309
1EF8		0059 0303
1EF9		0079 0303
1F00		03B1 0313
1F01		03B1 0314
1F02		1F00 0300
1F03		1F01 0300
1F04		1F00 0301
1F05		1F01 0301
1F06		1F00 0342
1F07		1F01 0342
1F08		0391 0313
1F09		0391 0314
1F0A		1F08 0300
1F0B		1F09 0300
1F0C		1F08 0301
1F0D		1F09 0301
1F0E		1F08 0342
1F0F		1F09 0342
1F10		03B5 0313
1F11		03B5 0314
1F12		1F10 0300
1F13		1F11 0300
1F14		1F10 0301
1F15		1F11 0301
1F18		0395 0313
1F19		0395 0314
1F1A		1F18 0300
1F1B		1F19 0300
1F1C		1F18 0301
1F1D		1F19 0301
1F20		03B7 0313
1F21		03B7 0314
1F22		1F20 0300
1F23		1F21 0300
1F24		1F20 0301
1F25		1F21 0301
1F26		1F20 0342
1F27		1F21 0342
1F28		0397 0313
1F29		0397 0314
1F2A		1F28 0300
1F2B		1F29 0300
1F2C		1F28 0301
1F2D		1F29 0301
1F2E		1F28 0342
1F2F		1F29 0342
1F30		03B9 0313
1F31		03B9 0314
1F32		1F30 0300
1F33		1F31 0300
1F34		1F30 0301
1F35		1F31 0301
1F36		1F30 0342
1F37		1F31 0342
1F38		0399 0313
1F39		0399 0314
1F3A		1F38 0300
1F3B		1F39 0300
1F3C		1F38 0301
1F3D		1F39 0301
1F3E		1F38 0342
1F3F		1F39 0342
1F40		03BF 0313
1F41		03BF 0314
1F42		1F40 0300
1F43		1F41 0300
1F44		1F40 0301
1F45		1F41 0301
1F48		039F 0313
1F49		039F 0314
1F4A		1F48 0300
1F4B		1F49 0300
1F4C		1F48 0301
1F4D		1F49 0301
1F50		03C5 0313
1F51		03C5 0314
1F52		1F50 0300
1F53		1F51 0300
1F54		1F50 0301
1F55		1F51 0301
1F56		1F50 0342
1F57		1F51 0342
1F59		03A5 0314
1F5B		1F59 0300
1F5D		1F59 0301
1F5F		1F59 0342
1F60		03C9 0313
1F61		03C9 0314
1F62		1F60 0300
1F63		1F61 0300
1F64		1F60 0301
1F65		1F61 0301
1F66		1F60 0342
1F67		1F61 0342
1F68		03A9 0313
1F69		03A9 0314
1F6A		1F68 0300
1F6B		1F69 0300
1F6C		1F68 0301
1F6D		1F69 0301
1F6E		1F68 0342
1F6F		1F69 0342
1F70		03B1 0300
1F71		03AC
1F72		03B5 0300
1F73		03AD
1F74		03B7 0300
1F75		03AE
1F76		03B9 0300
1F77		03AF
1F78		03BF 0300
1F79		03CC
1F7A		03C5 0300
1F7B		03CD
1F7C		03C9 0300
1F7D		03CE
1F80		1F00 0345
1F81		1F01 0345
1F82		1F02 0345
1F83		1F03 0345
1F84		1F04 0345
1F85		1F05 0345
1F86		1F06 0345
1F87		1F07 0345
1F88		1F08 0345
1F89		1F09 0345
1F8A		1F0A 0345
1F8B		1F0B 0345
1F8C		1F0C 0345
1F8D		1F0D 0345
1F8E		1F0E 0345
1F8F		1F0F 0345
1F90		1F20 0345
1F91		1F21 0345
1F92		1F22 0345
1F93		1F23 0345
1F94		1F24 0345
1F95		1F25 0345
1F96		1F26 0345
1F97		1F27 0345
1F98		1F28 0345
1F99		1F29 0345
1F9A		1F2A 0345
1F9B		1F2B 0345
1F9C		1F2C 0345
1F9D		1F2D 0345
1F9E		1F2E 0345
1F9F		1F2F 0345
1FA0		1F60 0345
1FA1		1F61 0345
1FA2		1F62 0345
1FA3		1F63 0345
1FA4		1F64 0345
1FA5		1F65 0345
1FA6		1F66 0345
1FA7		1F67 0345
1FA8		1F68 0345
1FA9		1F69 0345
1FAA		1F6A 0345
1FAB		1F6B 0345
1FAC		1F6C 0345
1FAD		1F6D 0345
1FAE		1F6E 0345
1FAF		1F6F 0345
1FB0		03B1 0306
1FB1		03B1 0304
1FB2		1F70 0345
1FB3		03B1 0345
1FB4		03AC 0345
1FB6		03B1 0342
1FB7		1FB6 0345
1FB8		0391 0306
1FB9		0391 0304
1FBA		0391 0300
1FBB		0386
1FBC		0391 0345
1FBD		<compat> 0020 0313
1FBE		03B9
1FBF		<compat> 0020 0313
1FC0		<compat> 0020 0342
1FC1		00A8 0342
1FC2		1F74 0345
1FC3		03B7 0345
1FC4		03AE 0345
1FC6		03B7 0342
1FC7		1FC6 0345
1FC8		0395 0300
1FC9		0388
1FCA		0397 0300
1FCB		0389
1FCC		0397 0345
1FCD		1FBF 0300
1FCE		1FBF 0301
1FCF		1FBF 0342
1FD0		03B9 0306
1FD1		03B9 0304
1FD2		03CA 0300
1FD3		0390
1FD6		03B9 0342
1FD7		03CA 0342
1FD8		0399 0306
1FD9		0399 0304
1FDA		0399 0300
1FDB		038A
1FDD		1FFE 0300
1FDE		1FFE 0301
1FDF		1FFE 0342
1FE0		03C5 0306
1FE1		03C5 0304
1FE2		03CB 0300
1FE3		03B0
1FE4		03C1 0313
1FE5		03C1 0314
1FE6		03C5 0342
1FE7		03CB 0342
1FE8		03A5 0306
1FE9		03A5 0304
1FEA		03A5 0300
1FEB		038E
1FEC		03A1 0314
1FED		00A8 0300
1FEE		0385
1FEF		0060
1FF2		1F7C 0345
1FF3		03C9 0345
1FF4		03CE 0345
1FF6		03C9 0342
1FF7		1FF6 0345
1FF8		039F 0300
1FF9		038C
1FFA		03A9 0300
1FFB		038F
1FFC		03A9 0345
1FFD		00B4
1FFE		<compat> 0020 0314
2000		2002
2001		2003
2002	2006	<compat> 0020
2007		<noBreak> 0020
2008	200A	<compat> 0020
2011		<noBreak> 2010
2017		<compat> 0020 0333
2024		<compat> 002E
2025		<compat> 002E 002E
2026		<compat> 002E 002E 002E
202F		<noBreak> 0020
2033		<compat> 2032 2032
2034		<compat> 2032 2032 2032
2036		<compat> 2035 2035
2037		<compat> 2035 2035 2035
203C		<compat> 0021 0021
203E		<compat> 0020 0305
2047		<compat> 003F 003F
2048		<compat> 003F 0021
2049		<compat> 0021 003F
2057		<compat> 2032 2032 2032 2032
205F		<compat> 0020
2070		<super> 0030
2071		<super> 0069
2074		<super> 0034
2075		<super> 0035
2076		<super> 0036
2077		<super> 0037
2078		<super> 0038
2079		<super> 0039
207A		<super> 002B
207B		<super> 2212
207C		<super> 003D
207D		<super> 0028
207E		<super> 0029
207F		<super> 006E
2080		<sub> 0030
2081		<sub> 0031
2082		<sub> 0032
2083		<sub> 0033
2084		<sub> 0034
2085		<sub> 0035
2086		<sub> 0036
2087		<sub> 0037
2088		<sub> 0038
2089		<sub> 0039
208A		<sub> 002B
208B		<sub> 2212
208C		<sub> 003D
208D		<sub> 0028
208E		<sub> 0029
2090		<sub> 0061
2091		<sub> 0065
2092		<sub> 006F
2093		<sub> 0078
2094		<sub> 0259
2095		<sub> 0068
2096		<sub> 006B
2097		<sub> 006C
2098		<sub> 006D
2099		<sub> 006E
209A		<sub> 0070
209B		<sub> 0073
209C		<sub> 0074
20A8		<compat> 0052 0073
2100		<compat> 0061 002F 0063
2101		<compat> 0061 002F 0073
2102		<font> 0043
2103		<compat> 00B0 0043
2105		<compat> 0063 002F 006F
2106		<compat> 0063 002F 0075
2107		<compat> 0190
2109		<compat> 00B0 0046
210A		<font> 0067
210B	210D	<font> 0048
210E		<font> 0068
210F		<font> 0127
2110	2111	<font> 0049
2112		<font> 004C
2113		<font> 006C
2115		<font> 004E
2116		<compat> 004E 006F
2119		<font> 0050
211A		<font> 0051
211B	211D	<font> 0052
2120		<super> 0053 004D
2121		<compat> 0054 0045 004C
2122		<super> 0054 004D
2124		<font> 005A
2126		03A9
2128		<font> 005A
212A		004B
212B		00C5
212C		<font> 0042
212D		<font> 0043
212F		<font> 0065
2130		<font> 0045
2131		<font> 0046
2133		<font> 004D
2134		<font> 006F
2135		<compat> 05D0
2136		<compat> 05D1
2137		<compat> 05D2
2138		<compat> 05D3
2139		<font> 0069
213B		<compat> 0046 0041 0058
213C		<font> 03C0
213D		<font> 03B3
213E		<font> 0393
213F		<font> 03A0
2140		<font> 2211
2145		<font> 0044
2146		<font> 0064
2147		<font> 0065
2148		<font> 0069
2149		<font> 006A
2150		<fraction> 0031 2044 0037
2151		<fraction> 0031 2044 0039
2152		<fraction> 0031 2044 0031 0030
2153		<fraction> 0031 2044 0033
2154		<fraction> 0032 2044 0033
2155		<fraction> 0031 2044 0035
2156		<fraction> 0032 2044 0035
2157		<fraction> 0033 2044 0035
2158		<fraction> 0034 2044 0035
2159		<fraction> 0031 2044 0036
215A		<fraction> 0035 2044 0036
215B		<fraction> 0031 2044 0038
215C		<fraction> 0033 2044 0038
215D		<fraction> 0035 2044 0038
215E		<fraction> 0037 2044 0038
215F		<fraction> 0031 2044
2160		<compat> 0049
2161		<compat> 0049 0049
2162		<compat> 0049 0049 0049
2163		<compat> 0049 0056
2164		<compat> 0056
2165		<compat> 0056 0049
2166		<compat> 0056 0049 0049
2167		<compat> 0056 0049 0049 0049
2168		<compat> 0049 0058
2169		<compat> 0058
216A		<compat> 0058 0049
216B		<compat> 0058 0049 0049
216C		<compat> 004C
216D		<compat> 0043
216E		<compat> 0044
216F		<compat> 004D
2170		<compat> 0069
2171		<compat> 0069 0069
2172		<compat> 0069 0069 0069
2173		<compat> 0069 0076
2174		<compat> 0076
2175		<compat> 0076 0069
2176		<compat> 0076 0069 0069
2177		<compat> 0076 0069 0069 0069
2178		<compat> 0069 0078
2179		<compat> 0078
217A		<compat> 0078 0069
217B		<compat> 0078 0069 0069
217C		<compat> 006C
217D		<compat> 0063
217E		<compat> 0064
217F		<compat> 006D
2189		<fraction> 0030 2044 0033
219A		2190 0338
219B		2192 0338
21AE		2194 0338
21CD		21D0 0338
21CE		21D4 0338
21CF		21D2 0338
2204		2203 0338
2209		2208 0338
220C		220B 0338
2224		2223 0338
2226		2225 0338
222C		<compat> 222B 222B
222D		<compat> 222B 222B 222B
222F		<compat> 222E 222E
2230		<compat> 222E 222E 222E
2241		223C 0338
2244		2243 0338
2247		2245 0338
2249		2248 0338
2260		003D 0338
2262		2261 0338
226D		224D 0338
226E		003C 0338
226F		003E 0338
2270		2264 0338
2271		2265 0338
2274		2272 0338
2275		2273 0338
2278		2276 0338
2279		2277 0338
2280		227A 0338
2281		227B 0338
2284		2282 0338
2285		2283 0338
2288		2286 0338
2289		2287 0338
22AC		22A2 0338
22AD		22A8 0338
22AE		22A9 0338
22AF		22AB 0338
22E0		227C 0338
22E1		227D 0338
22E2		2291 0338
22E3		2292 0338
22EA		22B2 0338
22EB		22B3 0338
22EC		22B4 0338
22ED		22B5 0338
2329		3008
232A		3009
2460		<circle> 0031
2461		<circle> 0032
2462		<circle> 0033
2463		<circle> 0034
2464		<circle> 0035
2465		<circle> 0036
2466		<circle> 0037
2467		<circle> 0038
2468		<circle> 0039
2469		<circle> 0031 0030
246A		<circle> 0031 0031
246B		<circle> 0031 0032
246C		<circle> 0031 0033
246D		<circle> 0031 0034
246E		<circle> 0031 0035
246F		<circle> 0031 0036
2470		<circle> 0031 0037
2471		<circle> 0031 0038
2472		<circle> 0031 0039
2473		<circle> 0032 0030
2474		<compat> 0028 0031 0029
2475		<compat> 0028 0032 0029
2476		<compat> 0028 0033 0029
2477		<compat> 0028 0034 0029
2478		<compat> 0028 0035 0029
2479		<compat> 0028 0036 0029
247A		<compat> 0028 0037 0029
247B		<compat> 0028 0038 0029
247C		<compat> 0028 0039 0029
247D		<compat> 0028 0031 0030 0029
247E		<compat> 0028 0031 0031 0029
247F		<compat> 0028 0031 0032 0029
2480		<compat> 0028 0031 0033 0029
2481		<compat> 0028 0031 0034 0029
2482		<compat> 0028 0031 0035 0029
2483		<compat> 0028 0031 0036 0029
2484		<compat> 0028 0031 0037 0029
2485		<compat> 0028 0031 0038 0029
2486		<compat> 0028 0031 0039 0029
2487		<compat> 0028 0032 0030 0029
2488		<compat> 0031 002E
2489		<compat> 0032 002E
248A		<compat> 0033 002E
248B		<compat> 0034 002E
248C		<compat> 0035 002E
248D		<compat> 0036 002E
248E		<compat> 0037 002E
248F		<compat> 0038 002E
2490		<compat> 0039 002E
2491		<compat> 0031 0030 002E
2492		<compat> 0031 0031 002E
2493		<compat> 0031 0032 002E
2494		<compat> 0031 0033 002E
2495		<compat> 0031 0034 002E
2496		<compat> 0031 0035 002E
2497		<compat> 0031 0036 002E
2498		<compat> 0031 0037 002E
2499		<compat> 0031 0038 002E
249A		<compat> 0031 0039 002E
249B		<compat> 0032 0030 002E
249C		<compat> 0028 0061 0029
249D		<compat> 0028 0062 0029
249E		<compat> 0028 0063 0029
249F		<compat> 0028 0064 0029
24A0		<compat> 0028 0065 0029
24A1		<compat> 0028 0066 0029
24A2		<compat> 0028 0067 0029
24A3		<compat> 0028 0068 0029
24A4		<compat> 0028 0069 0029
24A5		<compat> 0028 006A 0029
24A6		<compat> 0028 006B 0029
24A7		<compat> 0028 006C 0029
24A8		<compat> 0028 006D 0029
24A9		<compat> 0028 006E 0029
24AA		<compat> 0028 006F 0029
24AB		<compat> 0028 0070 0029
24AC		<compat> 0028 0071 0029
24AD		<compat> 0028 0072 0029
24AE		<compat> 0028 0073 0029
24AF		<compat> 0028 0074 0029
24B0		<compat> 0028 0075 0029
24B1		<compat> 0028 0076 0029
24B2		<compat> 0028 0077 0029
24B3		<compat> 0028 0078 0029
24B4		<compat> 0028 0079 0029
24B5		<compat> 0028 007A 0029
24B6		<circle> 0041
24B7		<circle> 0042
24B8		<circle> 0043
24B9		<circle> 0044
24BA		<circle> 0045
24BB		<circle> 0046
24BC		<circle> 0047
24BD		<circle> 0048
24BE		<circle> 0049
24BF		<circle> 004A
24C0		<circle> 004B
24C1		<circle> 004C
24C2		<circle> 004D
24C3		<circle> 004E
24C4		<circle> 004F
24C5		<circle> 0050
24C6		<circle> 0051
24C7		<circle> 0052
24C8		<circle> 0053
24C9		<circle> 0054
24CA		<circle> 0055
24CB		<circle> 0056
24CC		<circle> 0057
24CD		<circle> 0058
24CE		<circle> 0059
24CF		<circle> 005A
24D0		<circle> 0061
24D1		<circle> 0062
24D2		<circle> 0063
24D3		<circle> 0064
24D4		<circle> 0065
24D5		<circle> 0066
24D6		<circle> 0067
24D7		<circle> 0068
24D8		<circle> 0069
24D9		<circle> 006A
24DA		<circle> 006B
24DB		<circle> 006C
24DC		<circle> 006D
24DD		<circle> 006E
24DE		<circle> 006F
24DF		<circle> 0070
24E0		<circle> 0071
24E1		<circle> 0072
24E2		<circle> 0073
24E3		<circle> 0074
24E4		<circle> 0075
24E5		<circle> 0076
24E6		<circle> 0077
24E7		<circle> 0078
24E8		<circle> 0079
24E9		<circle> 007A
24EA		<circle> 0030
2A0C		<compat> 222B 222B 222B 222B
2A74		<compat> 003A 003A 003D
2A75		<compat> 003D 003D
2A76		<compat> 003D 003D 003D
2ADC		2ADD 0338
2C7C		<sub> 006A
2C7D		<super> 0056
2D6F		<super> 2D61
2E9F		<compat> 6BCD
2EF3		<compat> 9F9F
2F00		<compat> 4E00
2F01		<compat> 4E28
2F02		<compat> 4E36
2F03		<compat> 4E3F
2F04		<compat> 4E59
2F05		<compat> 4E85
2F06		<compat> 4E8C
2F07		<compat> 4EA0
2F08		<compat> 4EBA
2F09		<compat> 513F
2F0A		<compat> 5165
2F0B		<compat> 516B
2F0C		<compat> 5182
2F0D		<compat> 5196
2F0E		<compat> 51AB
2F0F		<compat> 51E0
2F10		<compat> 51F5
2F11		<compat> 5200
2F12		<compat> 529B
2F13		<compat> 52F9
2F14		<compat> 5315
2F15		<compat> 531A
2F16		<compat> 5338
2F17		<compat> 5341
2F18		<compat> 535C
2F19		<compat> 5369
2F1A		<compat> 5382
2F1B		<compat> 53B6
2F1C		<compat> 53C8
2F1D		<compat> 53E3
2F1E		<compat> 56D7
2F1F		<compat> 571F
2F20		<compat> 58EB
2F21		<compat> 5902
2F22		<compat> 590A
2F23		<compat> 5915
2F24		<compat> 5927
2F25		<compat> 5973
2F26		<compat> 5B50
2F27		<compat> 5B80
2F28		<compat> 5BF8
2F29		<compat> 5C0F
2F2A		<compat> 5C22
2F2B		<compat> 5C38
2F2C		<compat> 5C6E
2F2D		<compat> 5C71
2F2E		<compat> 5DDB
2F2F		<compat> 5DE5
2F30		<compat> 5DF1
2F31		<compat> 5DFE
2F32		<compat> 5E72
2F33		<compat> 5E7A
2F34		<compat> 5E7F
2F35		<compat> 5EF4
2F36		<compat> 5EFE
2F37		<compat> 5F0B
2F38		<compat> 5F13
2F39		<compat> 5F50
2F3A		<compat> 5F61
2F3B		<compat> 5F73
2F3C		<compat> 5FC3
2F3D		<compat> 6208
2F3E		<compat> 6236
2F3F		<compat> 624B
2F40		<compat> 652F
2F41		<compat> 6534
2F42		<compat> 6587
2F43		<compat> 6597
2F44		<compat> 65A4
2F45		<compat> 65B9
2F46		<compat> 65E0
2F47		<compat> 65E5
2F48		<compat> 66F0
2F49		<compat> 6708
2F4A		<compat> 6728
2F4B		<compat> 6B20
2F4C		<compat> 6B62
2F4D		<compat> 6B79
2F4E		<compat> 6BB3
2F4F		<compat> 6BCB
2F50		<compat> 6BD4
2F51		<compat> 6BDB
2F52		<compat> 6C0F
2F53		<compat> 6C14
2F54		<compat> 6C34
2F55		<compat> 706B
2F56		<compat> 722A
2F57		<compat> 7236
2F58		<compat> 723B
2F59		<compat> 723F
2F5A		<compat> 7247
2F5B		<compat> 7259
2F5C		<compat> 725B
2F5D		<compat> 72AC
2F5E		<compat> 7384
2F5F		<compat> 7389
2F60		<compat> 74DC
2F61		<compat> 74E6
2F62		<compat> 7518
2F63		<compat> 751F
2F64		<compat> 7528
2F65		<compat> 7530
2F66		<compat> 758B
2F67		<compat> 7592
2F68		<compat> 7676
2F69		<compat> 767D
2F6A		<compat> 76AE
2F6B		<compat> 76BF
2F6C		<compat> 76EE
2F6D		<compat> 77DB
2F6E		<compat> 77E2
2F6F		<compat> 77F3
2F70		<compat> 793A
2F71		<compat> 79B8
2F72		<compat> 79BE
2F73		<compat> 7A74
2F74		<compat> 7ACB
2F75		<compat> 7AF9
2F76		<compat> 7C73
2F77		<compat> 7CF8
2F78		<compat> 7F36
2F79		<compat> 7F51
2F7A		<compat> 7F8A
2F7B		<compat> 7FBD
2F7C		<compat> 8001
2F7D		<compat> 800C
2F7E		<compat> 8012
2F7F		<compat> 8033
2F80		<compat> 807F
2F81		<compat> 8089
2F82		<compat> 81E3
2F83		<compat> 81EA
2F84		<compat> 81F3
2F85		<compat> 81FC
2F86		<compat> 820C
2F87		<compat> 821B
2F88		<compat> 821F
2F89		<compat> 826E
2F8A		<compat> 8272
2F8B		<compat> 8278
2F8C		<compat> 864D
2F8D		<compat> 866B
2F8E		<compat> 8840
2F8F		<compat> 884C
2F90		<compat> 8863
2F91		<compat> 897E
2F92		<compat> 898B
2F93		<compat> 89D2
2F94		<compat> 8A00
2F95		<compat> 8C37
2F96		<compat> 8C46
2F97		<compat> 8C55
2F98		<compat> 8C78
2F99		<compat> 8C9D
2F9A		<compat> 8D64
2F9B		<compat> 8D70
2F9C		<compat> 8DB3
2F9D		<compat> 8EAB
2F9E		<compat> 8ECA
2F9F		<compat> 8F9B
2FA0		<compat> 8FB0
2FA1		<compat> 8FB5
2FA2		<compat> 9091
2FA3		<compat> 9149
2FA4		<compat> 91C6
2FA5		<compat> 91CC
2FA6		<compat> 91D1
2FA7		<compat> 9577
2FA8		<compat> 9580
2FA9		<compat> 961C
2FAA		<compat> 96B6
2FAB		<compat> 96B9
2FAC		<compat> 96E8
2FAD		<compat> 9751
2FAE		<compat> 975E
2FAF		<compat> 9762
2FB0		<compat> 9769
2FB1		<compat> 97CB
2FB2		<compat> 97ED
2FB3		<compat> 97F3
2FB4		<compat> 9801
2FB5		<compat> 98A8
2FB6		<compat> 98DB
2FB7		<compat> 98DF
2FB8		<compat> 9996
2FB9		<compat> 9999
2FBA		<compat> 99AC
2FBB		<compat> 9AA8
2FBC		<compat> 9AD8
2FBD		<compat> 9ADF
2FBE		<compat> 9B25
2FBF		<compat> 9B2F
2FC0		<compat> 9B32
2FC1		<compat> 9B3C
2FC2		<compat> 9B5A
2FC3		<compat> 9CE5
2FC4		<compat> 9E75
2FC5		<compat> 9E7F
2FC6		<compat> 9EA5
2FC7		<compat> 9EBB
2FC8		<compat> 9EC3
2FC9		<compat> 9ECD
2FCA		<compat> 9ED1
2FCB		<compat> 9EF9
2FCC		<compat> 9EFD
2FCD		<compat> 9F0E
2FCE		<compat> 9F13
2FCF		<compat> 9F20
2FD0		<compat> 9F3B
2FD1		<compat> 9F4A
2FD2		<compat> 9F52
2FD3		<compat> 9F8D
2FD4		<compat> 9F9C
2FD5		<compat> 9FA0
3000		<wide> 0020
3036		<compat> 3012
3038		<compat> 5341
3039		<compat> 5344
303A		<compat> 5345
304C		304B 3099
304E		304D 3099
3050		304F 3099
3052		3051 3099
3054		3053 3099
3056		3055 3099
3058		3057 3099
305A		3059 3099
305C		305B 3099
305E		305D 3099
3060		305F 3099
3062		3061 3099
3065		3064 3099
3067		3066 3099
3069		3068 3099
3070		306F 3099
3071		306F 309A
3073		3072 3099
3074		3072 309A
3076		3075 3099
3077		3075 309A
3079		3078 3099
307A		3078 309A
307C		307B 3099
307D		307B 309A
3094		3046 3099
309B		<compat> 0020 3099
309C		<compat> 0020 309A
309E		309D 3099
309F		<vertical> 3088 308A
30AC		30AB 3099
30AE		30AD 3099
30B0		30AF 3099
30B2		30B1 3099
30B4		30B3 3099
30B6		30B5 3099
30B8		30B7 3099
30BA		30B9 3099
30BC		30BB 3099
30BE		30BD 3099
30C0		30BF 3099
30C2		30C1 3099
30C5		30C4 3099
30C7		30C6 3099
30C9		30C8 3099
30D0		30CF 3099
30D1		30CF 309A
30D3		30D2 3099
30D4		30D2 309A
30D6		30D5 3099
30D7		30D5 309A
30D9		30D8 3099
30DA		30D8 309A
30DC		30DB 3099
30DD		30DB 309A
30F4		30A6 3099
30F7		30EF 3099
30F8		30F0 3099
30F9		30F1 3099
30FA		30F2 3099
30FE		30FD 3099
30FF		<vertical> 30B3 30C8
3131		<compat> 1100
3132		<compat> 1101
3133		<compat> 11AA
3134		<compat> 1102
3135		<compat> 11AC
3136		<compat> 11AD
3137		<compat> 1103
3138		<compat> 1104
3139		<compat> 1105
313A		<compat> 11B0
313B		<compat> 11B1
313C		<compat> 11B2
313D		<compat> 11B3
313E		<compat> 11B4
313F		<compat> 11B5
3140		<compat> 111A
3141		<compat> 1106
3142		<compat> 1107
3143		<compat> 1108
3144		<compat> 1121
3145		<compat> 1109
3146		<compat> 110A
3147		<compat> 110B
3148		<compat> 110C
3149		<compat> 110D
314A		<compat> 110E
314B		<compat> 110F
314C		<compat> 1110
314D		<compat> 1111
314E		<compat> 1112
314F		<compat> 1161
3150		<compat> 1162
3151		<compat> 1163
3152		<compat> 1164
3153		<compat> 1165
3154		<compat> 1166
3155		<compat> 1167
3156		<compat> 1168
3157		<compat> 1169
3158		<compat> 116A
3159		<compat> 116B
315A		<compat> 116C
315B		<compat> 116D
315C		<compat> 116E
315D		<compat> 116F
315E		<compat> 1170
315F		<compat> 1171
3160		<compat> 1172
3161		<compat> 1173
3162		<compat> 1174
3163		<compat> 1175
3164		<compat> 1160
3165		<compat> 1114
3166		<compat> 1115
3167		<compat> 11C7
3168		<compat> 11C8
3169		<compat> 11CC
316A		<compat> 11CE
316B		<compat> 11D3
316C		<compat> 11D7
316D		<compat> 11D9
316E		<compat> 111C
316F		<compat> 11DD
3170		<compat> 11DF
3171		<compat> 111D
3172		<compat> 111E
3173		<compat> 1120
3174		<compat> 1122
3175		<compat> 1123
3176		<compat> 1127
3177		<compat> 1129
3178		<compat> 112B
3179		<compat> 112C
317A		<compat> 112D
317B		<compat> 112E
317C		<compat> 112F
317D		<compat> 1132
317E		<compat> 1136
317F		<compat> 1140
3180		<compat> 1147
3181		<compat> 114C
3182		<compat> 11F1
3183		<compat> 11F2
3184		<compat> 1157
3185		<compat> 1158
3186		<compat> 1159
3187		<compat> 1184
3188		<compat> 1185
3189		<compat> 1188
318A		<compat> 1191
318B		<compat> 1192
318C		<compat> 1194
318D		<compat> 119E
318E		<compat> 11A1
3192		<super> 4E00
3193		<super> 4E8C
3194		<super> 4E09
3195		<super> 56DB
3196		<super> 4E0A
3197		<super> 4E2D
3198		<super> 4E0B
3199		<super> 7532
319A		<super> 4E59
319B		<super> 4E19
319C		<super> 4E01
319D		<super> 5929
319E		<super> 5730
319F		<super> 4EBA
3200		<compat> 0028 1100 0029
3201		<compat> 0028 1102 0029
3202		<compat> 0028 1103 0029
3203		<compat> 0028 1105 0029
3204		<compat> 0028 1106 0029
3205		<compat> 0028 1107 0029
3206		<compat> 0028 1109 0029
3207		<compat> 0028 110B 0029
3208		<compat> 0028 110C 0029
3209		<compat> 0028 110E 0029
320A		<compat> 0028 110F 0029
320B		<compat> 0028 1110 0029
320C		<compat> 0028 1111 0029
320D		<compat> 0028 1112 0029
320E		<compat> 0028 1100 1161 0029
320F		<compat> 0028 1102 1161 0029
3210		<compat> 0028 1103 1161 0029
3211		<compat> 0028 1105 1161 0029
3212		<compat> 0028 1106 1161 0029
3213		<compat> 0028 1107 1161 0029
3214		<compat> 0028 1109 1161 0029
3215		<compat> 0028 110B 1161 0029
3216		<compat> 0028 110C 1161 0029
3217		<compat> 0028 110E 1161 0029
3218		<compat> 0028 110F 1161 0029
3219		<compat> 0028 1110 1161 0029
321A		<compat> 0028 1111 1161 0029
321B		<compat> 0028 1112 1161 0029
321C		<compat> 0028 110C 116E 0029
321D		<compat> 0028 110B 1169 110C 1165 11AB 0029
321E		<compat> 0028 110B 1169 1112 116E 0029
3220		<compat> 0028 4E00 0029
3221		<compat> 0028 4E8C 0029
3222		<compat> 0028 4E09 0029
3223		<compat> 0028 56DB 0029
3224		<compat> 0028 4E94 0029
3225		<compat> 0028 516D 0029
3226		<compat> 0028 4E03 0029
3227		<compat> 0028 516B 0029
3228		<compat> 0028 4E5D 0029
3229		<compat> 0028 5341 0029
322A		<compat> 0028 6708 0029
322B		<compat> 0028 706B 0029
322C		<compat> 0028 6C34 0029
322D		<compat> 0028 6728 0029
322E		<compat> 0028 91D1 0029
322F		<compat> 0028 571F 0029
3230		<compat> 0028 65E5 0029
3231		<compat> 0028 682A 0029
3232		<compat> 0028 6709 0029
3233		<compat> 0028 793E 0029
3234		<compat> 0028 540D 0029
3235		<compat> 0028 7279 0029
3236		<compat> 0028 8CA1 0029
3237		<compat> 0028 795D 0029
3238		<compat> 0028 52B4 0029
3239		<compat> 0028 4EE3 0029
323A		<compat> 0028 547C 0029
323B		<compat> 0028 5B66 0029
323C		<compat> 0028 76E3 0029
323D		<compat> 0028 4F01 0029
323E		<compat> 0028 8CC7 0029
323F		<compat> 0028 5354 0029
3240		<compat> 0028 796D 0029
3241		<compat> 0028 4F11 0029
3242		<compat> 0028 81EA 0029
3243		<compat> 0028 81F3 0029
3244		<circle> 554F
3245		<circle> 5E7C
3246		<circle> 6587
3247		<circle> 7B8F
3250		<square> 0050 0054 0045
3251		<circle> 0032 0031
3252		<circle> 0032 0032
3253		<circle> 0032 0033
3254		<circle> 0032 0034
3255		<circle> 0032 0035
3256		<circle> 0032 0036
3257		<circle> 0032 0037
3258		<circle> 0032 0038
3259		<circle> 0032 0039
325A		<circle> 0033 0030
325B		<circle> 0033 0031
325C		<circle> 0033 0032
325D		<circle> 0033 0033
325E		<circle> 0033 0034
325F		<circle> 0033 0035
3260		<circle> 1100
3261		<circle> 1102
3262		<circle> 1103
3263		<circle> 1105
3264		<circle> 1106
3265		<circle> 1107
3266		<circle> 1109
3267		<circle> 110B
3268		<circle> 110C
3269		<circle> 110E
326A		<circle> 110F
326B		<circle> 1110
326C		<circle> 1111
326D		<circle> 1112
326E		<circle> 1100 1161
326F		<circle> 1102 1161
3270		<circle> 1103 1161
3271		<circle> 1105 1161
3272		<circle> 1106 1161
3273		<circle> 1107 1161
3274		<circle> 1109 1161
3275		<circle> 110B 1161
3276		<circle> 110C 1161
3277		<circle> 110E 1161
3278		<circle> 110F 1161
3279		<circle> 1110 1161
327A		<circle> 1111 1161
327B		<circle> 1112 1161
327C		<circle> 110E 1161 11B7 1100 1169
327D		<circle> 110C 116E 110B 1174
327E		<circle> 110B 116E
3280		<circle> 4E00
3281		<circle> 4E8C
3282		<circle> 4E09
3283		<circle> 56DB
3284		<circle> 4E94
3285		<circle> 516D
3286		<circle> 4E03
3287		<circle> 516B
3288		<circle> 4E5D
3289		<circle> 5341
328A		<circle> 6708
328B		<circle> 706B
328C		<circle> 6C34
328D		<circle> 6728
328E		<circle> 91D1
328F		<circle> 571F
3290		<circle> 65E5
3291		<circle> 682A
3292		<circle> 6709
3293		<circle> 793E
3294		<circle> 540D
3295		<circle> 7279
3296		<circle> 8CA1
3297		<circle> 795D
3298		<circle> 52B4
3299		<circle> 79D8
329A		<circle> 7537
329B		<circle> 5973
329C		<circle> 9069
329D		<circle> 512A
329E		<circle> 5370
329F		<circle> 6CE8
32A0		<circle> 9805
32A1		<circle> 4F11
32A2		<circle> 5199
32A3		<circle> 6B63
32A4		<circle> 4E0A
32A5		<circle> 4E2D
32A6		<circle> 4E0B
32A7		<circle> 5DE6
32A8		<circle> 53F3
32A9		<circle> 533B
32AA		<circle> 5B97
32AB		<circle> 5B66
32AC		<circle> 76E3
32AD		<circle> 4F01
32AE		<circle> 8CC7
32AF		<circle> 5354
32B0		<circle> 591C
32B1		<circle> 0033 0036
32B2		<circle> 0033 0037
32B3		<circle> 0033 0038
32B4		<circle> 0033 0039
32B5		<circle> 0034 0030
32B6		<circle> 0034 0031
32B7		<circle> 0034 0032
32B8		<circle> 0034 0033
32B9		<circle> 0034 0034
32BA		<circle> 0034 0035
32BB		<circle> 0034 0036
32BC		<circle> 0034 0037
32BD		<circle> 0034 0038
32BE		<circle> 0034 0039
32BF		<circle> 0035 0030
32C0		<compat> 0031 6708
32C1		<compat> 0032 6708
32C2		<compat> 0033 6708
32C3		<compat> 0034 6708
32C4		<compat> 0035 6708
32C5		<compat> 0036 6708
32C6		<compat> 0037 6708
32C7		<compat> 0038 6708
32C8		<compat> 0039 6708
32C9		<compat> 0031 0030 6708
32CA		<compat> 0031 0031 6708
32CB		<compat> 0031 0032 6708
32CC		<square> 0048 0067
32CD		<square> 0065 0072 0067
32CE		<square> 0065 0056
32CF		<square> 004C 0054 0044
32D0		<circle> 30A2
32D1		<circle> 30A4
32D2		<circle> 30A6
32D3		<circle> 30A8
32D4		<circle> 30AA
32D5		<circle> 30AB
32D6		<circle> 30AD
32D7		<circle> 30AF
32D8		<circle> 30B1
32D9		<circle> 30B3
32DA		<circle> 30B5
32DB		<circle> 30B7
32DC		<circle> 30B9
32DD		<circle> 30BB
32DE		<circle> 30BD
32DF		<circle> 30BF
32E0		<circle> 30C1
32E1		<circle> 30C4
32E2		<circle> 30C6
32E3		<circle> 30C8
32E4		<circle> 30CA
32E5		<circle> 30CB
32E6		<circle> 30CC
32E7		<circle> 30CD
32E8		<circle> 30CE
32E9		<circle> 30CF
32EA		<circle> 30D2
32EB		<circle> 30D5
32EC		<circle> 30D8
32ED		<circle> 30DB
32EE		<circle> 30DE
32EF		<circle> 30DF
32F0		<circle> 30E0
32F1		<circle> 30E1
32F2		<circle> 30E2
32F3		<circle> 30E4
32F4		<circle> 30E6
32F5		<circle> 30E8
32F6		<circle> 30E9
32F7		<circle> 30EA
32F8		<circle> 30EB
32F9		<circle> 30EC
32FA		<circle> 30ED
32FB		<circle> 30EF
32FC		<circle> 30F0
32FD		<circle> 30F1
32FE		<circle> 30F2
32FF		<square> 4EE4 548C
3300		<square> 30A2 30D1 30FC 30C8
3301		<square> 30A2 30EB 30D5 30A1
3302		<square> 30A2 30F3 30DA 30A2
3303		<square> 30A2 30FC 30EB
3304		<square> 30A4 30CB 30F3 30B0
3305		<square> 30A4 30F3 30C1
3306		<square> 30A6 30A9 30F3
3307		<square> 30A8 30B9 30AF 30FC 30C9
3308		<square> 30A8 30FC 30AB 30FC
3309		<square> 30AA 30F3 30B9
330A		<square> 30AA 30FC 30E0
330B		<square> 30AB 30A4 30EA
330C		<square> 30AB 30E9 30C3 30C8
330D		<square> 30AB 30ED 30EA 30FC
330E		<square> 30AC 30ED 30F3
330F		<square> 30AC 30F3 30DE
3310		<square> 30AE 30AC
3311		<square> 30AE 30CB 30FC
3312		<square> 30AD 30E5 30EA 30FC
3313		<square> 30AE 30EB 30C0 30FC
3314		<square> 30AD 30ED
3315		<square> 30AD 30ED 30B0 30E9 30E0
3316		<square> 30AD 30ED 30E1 30FC 30C8 30EB
3317		<square> 30AD 30ED 30EF 30C3 30C8
3318		<square> 30B0 30E9 30E0
3319		<square> 30B0 30E9 30E0 30C8 30F3
331A		<square> 30AF 30EB 30BC 30A4 30ED
331B		<square> 30AF 30ED 30FC 30CD
331C		<square> 30B1 30FC 30B9
331D		<square> 30B3 30EB 30CA
331E		<square> 30B3 30FC 30DD
331F		<square> 30B5 30A4 30AF 30EB
3320		<square> 30B5 30F3 30C1 30FC 30E0
3321		<square> 30B7 30EA 30F3 30B0
3322		<square> 30BB 30F3 30C1
3323		<square> 30BB 30F3 30C8
3324		<square> 30C0 30FC 30B9
3325		<square> 30C7 30B7
3326		<square> 30C9 30EB
3327		<square> 30C8 30F3
3328		<square> 30CA 30CE
3329		<square> 30CE 30C3 30C8
332A		<square> 30CF 30A4 30C4
332B		<square> 30D1 30FC 30BB 30F3 30C8
332C		<square> 30D1 30FC 30C4
332D		<square> 30D0 30FC 30EC 30EB
332E		<square> 30D4 30A2 30B9 30C8 30EB
332F		<square> 30D4 30AF 30EB
3330		<square> 30D4 30B3
3331		<square> 30D3 30EB
3332		<square> 30D5 30A1 30E9 30C3 30C9
3333		<square> 30D5 30A3 30FC 30C8
3334		<square> 30D6 30C3 30B7 30A7 30EB
3335		<square> 30D5 30E9 30F3
3336		<square> 30D8 30AF 30BF 30FC 30EB
3337		<square> 30DA 30BD
3338		<square> 30DA 30CB 30D2
3339		<square> 30D8 30EB 30C4
333A		<square> 30DA 30F3 30B9
333B		<square> 30DA 30FC 30B8
333C		<square> 30D9 30FC 30BF
333D		<square> 30DD 30A4 30F3 30C8
333E		<square> 30DC 30EB 30C8
333F		<square> 30DB 30F3
3340		<square> 30DD 30F3 30C9
3341		<square> 30DB 30FC 30EB
3342		<square> 30DB 30FC 30F3
3343		<square> 30DE 30A4 30AF 30ED
3344		<square> 30DE 30A4 30EB
3345		<square> 30DE 30C3 30CF
3346		<square> 30DE 30EB 30AF
3347		<square> 30DE 30F3 30B7 30E7 30F3
3348		<square> 30DF 30AF 30ED 30F3
3349		<square> 30DF 30EA
334A		<square> 30DF 30EA 30D0 30FC 30EB
334B		<square> 30E1 30AC
334C		<square> 30E1 30AC 30C8 30F3
334D		<square> 30E1 30FC 30C8 30EB
334E		<square> 30E4 30FC 30C9
334F		<square> 30E4 30FC 30EB
3350		<square> 30E6 30A2 30F3
3351		<square> 30EA 30C3 30C8 30EB
3352		<square> 30EA 30E9
3353		<square> 30EB 30D4 30FC
3354		<square> 30EB 30FC 30D6 30EB
3355		<square> 30EC 30E0
3356		<square> 30EC 30F3 30C8 30B2 30F3
3357		<square> 30EF 30C3 30C8
3358		<compat> 0030 70B9
3359		<compat> 0031 70B9
335A		<compat> 0032 70B9
335B		<compat> 0033 70B9
335C		<compat> 0034 70B9
335D		<compat> 0035 70B9
335E		<compat> 0036 70B9
335F		<compat> 0037 70B9
3360		<compat> 0038 70B9
3361		<compat> 0039 70B9
3362		<compat> 0031 0030 70B9
3363		<compat> 0031 0031 70B9
3364		<compat> 0031 0032 70B9
3365		<compat> 0031 0033 70B9
3366		<compat> 0031 0034 70B9
3367		<compat> 0031 0035 70B9
3368		<compat> 0031 0036 70B9
3369		<compat> 0031 0037 70B9
336A		<compat> 0031 0038 70B9
336B		<compat> 0031 0039 70B9
336C		<compat> 0032 0030 70B9
336D		<compat> 0032 0031 70B9
336E		<compat> 0032 0032 70B9
336F		<compat> 0032 0033 70B9
3370		<compat> 0032 0034 70B9
3371		<square> 0068 0050 0061
3372		<square> 0064 0061
3373		<square> 0041 0055
3374		<square> 0062 0061 0072
3375		<square> 006F 0056
3376		<square> 0070 0063
3377		<square> 0064 006D
3378		<square> 0064 006D 00B2
3379		<square> 0064 006D 00B3
337A		<square> 0049 0055
337B		<square> 5E73 6210
337C		<square> 662D 548C
337D		<square> 5927 6B63
337E		<square> 660E 6CBB
337F		<square> 682A 5F0F 4F1A 793E
3380		<square> 0070 0041
3381		<square> 006E 0041
3382		<square> 03BC 0041
3383		<square> 006D 0041
3384		<square> 006B 0041
3385		<square> 004B 0042
3386		<square> 004D 0042
3387		<square> 0047 0042
3388		<square> 0063 0061 006C
3389		<square> 006B 0063 0061 006C
338A		<square> 0070 0046
338B		<square> 006E 0046
338C		<square> 03BC 0046
338D		<square> 03BC 0067
338E		<square> 006D 0067
338F		<square> 006B 0067
3390		<square> 0048 007A
3391		<square> 006B 0048 007A
3392		<square> 004D 0048 007A
3393		<square> 0047 0048 007A
3394		<square> 0054 0048 007A
3395		<square> 03BC 2113
3396		<square> 006D 2113
3397		<square> 0064 2113
3398		<square> 006B 2113
3399		<square> 0066 006D
339A		<square> 006E 006D
339B		<square> 03BC 006D
339C		<square> 006D 006D
339D		<square> 0063 006D
339E		<square> 006B 006D
339F		<square> 006D 006D 00B2
33A0		<square> 0063 006D 00B2
33A1		<square> 006D 00B2
33A2		<square> 006B 006D 00B2
33A3		<square> 006D 006D 00B3
33A4		<square> 0063 006D 00B3
33A5		<square> 006D 00B3
33A6		<square> 006B 006D 00B3
33A7		<square> 006D 2215 0073
33A8		<square> 006D 2215 0073 00B2
33A9		<square> 0050 0061
33AA		<square> 006B 0050 0061
33AB		<square> 004D 0050 0061
33AC		<square> 0047 0050 0061
33AD		<square> 0072 0061 0064
33AE		<square> 0072 0061 0064 2215 0073
33AF		<square> 0072 0061 0064 2215 0073 00B2
33B0		<square> 0070 0073
33B1		<square> 006E 0073
33B2		<square> 03BC 0073
33B3		<square> 006D 0073
33B4		<square> 0070 0056
33B5		<square> 006E 0056
33B6		<square> 03BC 0056
33B7		<square> 006D 0056
33B8		<square> 006B 0056
33B9		<square> 004D 0056
33BA		<square> 0070 0057
33BB		<square> 006E 0057
33BC		<square> 03BC 0057
33BD		<square> 006D 0057
33BE		<square> 006B 0057
33BF		<square> 004D 0057
33C0		<square> 006B 03A9
33C1		<square> 004D 03A9
33C2		<square> 0061 002E 006D 002E
33C3		<square> 0042 0071
33C4		<square> 0063 0063
33C5		<square> 0063 0064
33C6		<square> 0043 2215 006B 0067
33C7		<square> 0043 006F 002E
33C8		<square> 0064 0042
33C9		<square> 0047 0079
33CA		<square> 0068 0061
33CB		<square> 0048 0050
33CC		<square> 0069 006E
33CD		<square> 004B 004B
33CE		<square> 004B 004D
33CF		<square> 006B 0074
33D0		<square> 006C 006D
33D1		<square> 006C 006E
33D2		<square> 006C 006F 0067
33D3		<square> 006C 0078
33D4		<square> 006D 0062
33D5		<square> 006D 0069 006C
33D6		<square> 006D 006F 006C
33D7		<square> 0050 0048
33D8		<square> 0070 002E 006D 002E
33D9		<square> 0050 0050 004D
33DA		<square> 0050 0052
33DB		<square> 0073 0072
33DC		<square> 0053 0076
33DD		<square> 0057 0062
33DE		<square> 0056 2215 006D
33DF		<square> 0041 2215 006D
33E0		<compat> 0031 65E5
33E1		<compat> 0032 65E5
33E2		<compat> 0033 65E5
33E3		<compat> 0034 65E5
33E4		<compat> 0035 65E5
33E5		<compat> 0036 65E5
33E6		<compat> 0037 65E5
33E7		<compat> 0038 65E5
33E8		<compat> 0039 65E5
33E9		<compat> 0031 0030 65E5
33EA		<compat> 0031 0031 65E5
33EB		<compat> 0031 0032 65E5
33EC		<compat> 0031 0033 65E5
33ED		<compat> 0031 0034 65E5
33EE		<compat> 0031 0035 65E5
33EF		<compat> 0031 0036 65E5
33F0		<compat> 0031 0037 65E5
33F1		<compat> 0031 0038 65E5
33F2		<compat> 0031 0039 65E5
33F3		<compat> 0032 0030 65E5
33F4		<compat> 0032 0031 65E5
33F5		<compat> 0032 0032 65E5
33F6		<compat> 0032 0033 65E5
33F7		<compat> 0032 0034 65E5
33F8		<compat> 0032 0035 65E5
33F9		<compat> 0032 0036 65E5
33FA		<compat> 0032 0037 65E5
33FB		<compat> 0032 0038 65E5
33FC		<compat> 0032 0039 65E5
33FD		<compat> 0033 0030 65E5
33FE		<compat> 0033 0031 65E5
33FF		<square> 0067 0061 006C
A69C		<super> 044A
A69D		<super> 044C
A770		<super> A76F
A7F2		<super> 0043
A7F3		<super> 0046
A7F4		<super> 0051
A7F8		<super> 0126
A7F9		<super> 0153
AB5C		<super> A727
AB5D		<super> AB37
AB5E		<super> 026B
AB5F		<super> AB52
AB69		<super> 028D
F900		8C48
F901		66F4
F902		8ECA
F903		8CC8
F904		6ED1
F905		4E32
F906		53E5
F907	F908	9F9C
F909		5951
F90A		91D1
F90B		5587
F90C		5948
F90D		61F6
F90E		7669
F90F		7F85
F910		863F
F911		87BA
F912		88F8
F913		908F
F914		6A02
F915		6D1B
F916		70D9
F917		73DE
F918		843D
F919		916A
F91A		99F1
F91B		4E82
F91C		5375
F91D		6B04
F91E		721B
F91F		862D
F920		9E1E
F921		5D50
F922		6FEB
F923		85CD
F924		8964
F925		62C9
F926		81D8
F927		881F
F928		5ECA
F929		6717
F92A		6D6A
F92B		72FC
F92C		90CE
F92D		4F86
F92E		51B7
F92F		52DE
F930		64C4
F931		6AD3
F932		7210
F933		76E7
F934		8001
F935		8606
F936		865C
F937		8DEF
F938		9732
F939		9B6F
F93A		9DFA
F93B		788C
F93C		797F
F93D		7DA0
F93E		83C9
F93F		9304
F940		9E7F
F941		8AD6
F942		58DF
F943		5F04
F944		7C60
F945		807E
F946		7262
F947		78CA
F948		8CC2
F949		96F7
F94A		58D8
F94B		5C62
F94C		6A13
F94D		6DDA
F94E		6F0F
F94F		7D2F
F950		7E37
F951		964B
F952		52D2
F953		808B
F954		51DC
F955		51CC
F956		7A1C
F957		7DBE
F958		83F1
F959		9675
F95A		8B80
F95B		62CF
F95C		6A02
F95D		8AFE
F95E		4E39
F95F		5BE7
F960		6012
F961		7387
F962		7570
F963		5317
F964		78FB
F965		4FBF
F966		5FA9
F967		4E0D
F968		6CCC
F969		6578
F96A		7D22
F96B		53C3
F96C		585E
F96D		7701
F96E		8449
F96F		8AAA
F970		6BBA
F971		8FB0
F972		6C88
F973		62FE
F974		82E5
F975		63A0
F976		7565
F977		4EAE
F978		5169
F979		51C9
F97A		6881
F97B		7CE7
F97C		826F
F97D		8AD2
F97E		91CF
F97F		52F5
F980		5442
F981		5973
F982		5EEC
F983		65C5
F984		6FFE
F985		792A
F986		95AD
F987		9A6A
F988		9E97
F989		9ECE
F98A		529B
F98B		66C6
F98C		6B77
F98D		8F62
F98E		5E74
F98F		6190
F990		6200
F991		649A
F992		6F23
F993		7149
F994		7489
F995		79CA
F996		7DF4
F997		806F
F998		8F26
F999		84EE
F99A		9023
F99B		934A
F99C		5217
F99D		52A3
F99E		54BD
F99F		70C8
F9A0		88C2
F9A1		8AAA
F9A2		5EC9
F9A3		5FF5
F9A4		637B
F9A5		6BAE
F9A6		7C3E
F9A7		7375
F9A8		4EE4
F9A9		56F9
F9AA		5BE7
F9AB		5DBA
F9AC		601C
F9AD		73B2
F9AE		7469
F9AF		7F9A
F9B0		8046
F9B1		9234
F9B2		96F6
F9B3		9748
F9B4		9818
F9B5		4F8B
F9B6		79AE
F9B7		91B4
F9B8		96B8
F9B9		60E1
F9BA		4E86
F9BB		50DA
F9BC		5BEE
F9BD		5C3F
F9BE		6599
F9BF		6A02
F9C0		71CE
F9C1		7642
F9C2		84FC
F9C3		907C
F9C4		9F8D
F9C5		6688
F9C6		962E
F9C7		5289
F9C8		677B
F9C9		67F3
F9CA		6D41
F9CB		6E9C
F9CC		7409
F9CD		7559
F9CE		786B
F9CF		7D10
F9D0		985E
F9D1		516D
F9D2		622E
F9D3		9678
F9D4		502B
F9D5		5D19
F9D6		6DEA
F9D7		8F2A
F9D8		5F8B
F9D9		6144
F9DA		6817
F9DB		7387
F9DC		9686
F9DD		5229
F9DE		540F
F9DF		5C65
F9E0		6613
F9E1		674E
F9E2		68A8
F9E3		6CE5
F9E4		7406
F9E5		75E2
F9E6		7F79
F9E7		88CF
F9E8		88E1
F9E9		91CC
F9EA		96E2
F9EB		533F
F9EC		6EBA
F9ED		541D
F9EE		71D0
F9EF		7498
F9F0		85FA
F9F1		96A3
F9F2		9C57
F9F3		9E9F
F9F4		6797
F9F5		6DCB
F9F6		81E8
F9F7		7ACB
F9F8		7B20
F9F9		7C92
F9FA		72C0
F9FB		7099
F9FC		8B58
F9FD		4EC0
F9FE		8336
F9FF		523A
FA00		5207
FA01		5EA6
FA02		62D3
FA03		7CD6
FA04		5B85
FA05		6D1E
FA06		66B4
FA07		8F3B
FA08		884C
FA09		964D
FA0A		898B
FA0B		5ED3
FA0C		5140
FA0D		55C0
FA10		585A
FA12		6674
FA15		51DE
FA16		732A
FA17		76CA
FA18		793C
FA19		795E
FA1A		7965
FA1B		798F
FA1C		9756
FA1D		7CBE
FA1E		7FBD
FA20		8612
FA22		8AF8
FA25		9038
FA26		90FD
FA2A		98EF
FA2B		98FC
FA2C		9928
FA2D		9DB4
FA2E		90DE
FA2F		96B7
FA30		4FAE
FA31		50E7
FA32		514D
FA33		52C9
FA34		52E4
FA35		5351
FA36		559D
FA37		5606
FA38		5668
FA39		5840
FA3A		58A8
FA3B		5C64
FA3C		5C6E
FA3D		6094
FA3E		6168
FA3F		618E
FA40		61F2
FA41		654F
FA42		65E2
FA43		6691
FA44		6885
FA45		6D77
FA46		6E1A
FA47		6F22
FA48		716E
FA49		722B
FA4A		7422
FA4B		7891
FA4C		793E
FA4D		7949
FA4E		7948
FA4F		7950
FA50		7956
FA51		795D
FA52		798D
FA53		798E
FA54		7A40
FA55		7A81
FA56		7BC0
FA57		7DF4
FA58		7E09
FA59		7E41
FA5A		7F72
FA5B		8005
FA5C		81ED
FA5D	FA5E	8279
FA5F		8457
FA60		8910
FA61		8996
FA62		8B01
FA63		8B39
FA64		8CD3
FA65		8D08
FA66		8FB6
FA67		9038
FA68		96E3
FA69		97FF
FA6A		983B
FA6B		6075
FA6C		242EE
FA6D		8218
FA70		4E26
FA71		51B5
FA72		5168
FA73		4F80
FA74		5145
FA75		5180
FA76		52C7
FA77		52FA
FA78		559D
FA79		5555
FA7A		5599
FA7B		55E2
FA7C		585A
FA7D		58B3
FA7E		5944
FA7F		5954
FA80		5A62
FA81		5B28
FA82		5ED2
FA83		5ED9
FA84		5F69
FA85		5FAD
FA86		60D8
FA87		614E
FA88		6108
FA89		618E
FA8A		6160
FA8B		61F2
FA8C		6234
FA8D		63C4
FA8E		641C
FA8F		6452
FA90		6556
FA91		6674
FA92		6717
FA93		671B
FA94		6756
FA95		6B79
FA96		6BBA
FA97		6D41
FA98		6EDB
FA99		6ECB
FA9A		6F22
FA9B		701E
FA9C		716E
FA9D		77A7
FA9E		7235
FA9F		72AF
FAA0		732A
FAA1		7471
FAA2		7506
FAA3		753B
FAA4		761D
FAA5		761F
FAA6		76CA
FAA7		76DB
FAA8		76F4
FAA9		774A
FAAA		7740
FAAB		78CC
FAAC		7AB1
FAAD		7BC0
FAAE		7C7B
FAAF		7D5B
FAB0		7DF4
FAB1		7F3E
FAB2		8005
FAB3		8352
FAB4		83EF
FAB5		8779
FAB6		8941
FAB7		8986
FAB8		8996
FAB9		8ABF
FABA		8AF8
FABB		8ACB
FABC		8B01
FABD		8AFE
FABE		8AED
FABF		8B39
FAC0		8B8A
FAC1		8D08
FAC2		8F38
FAC3		9072
FAC4		9199
FAC5		9276
FAC6		967C
FAC7		96E3
FAC8		9756
FAC9		97DB
FACA		97FF
FACB		980B
FACC		983B
FACD		9B12
FACE		9F9C
FACF		2284A
FAD0		22844
FAD1		233D5
FAD2		3B9D
FAD3		4018
FAD4		4039
FAD5		25249
FAD6		25CD0
FAD7		27ED3
FAD8		9F43
FAD9		9F8E
FB00		<compat> 0066 0066
FB01		<compat> 0066 0069
FB02		<compat> 0066 006C
FB03		<compat> 0066 0066 0069
FB04		<compat> 0066 0066 006C
FB05		<compat> 017F 0074
FB06		<compat> 0073 0074
FB13		<compat> 0574 0576
FB14		<compat> 0574 0565
FB15		<compat> 0574 056B
FB16		<compat> 057E 0576
FB17		<compat> 0574 056D
FB1D		05D9 05B4
FB1F		05F2 05B7
FB20		<font> 05E2
FB21		<font> 05D0
FB22		<font> 05D3
FB23		<font> 05D4
FB24		<font> 05DB
FB25		<font> 05DC
FB26		<font> 05DD
FB27		<font> 05E8
FB28		<font> 05EA
FB29		<font> 002B
FB2A		05E9 05C1
FB2B		05E9 05C2
FB2C		FB49 05C1
FB2D		FB49 05C2
FB2E		05D0 05B7
FB2F		05D0 05B8
FB30		05D0 05BC
FB31		05D1 05BC
FB32		05D2 05BC
FB33		05D3 05BC
FB34		05D4 05BC
FB35		05D5 05BC
FB36		05D6 05BC
FB38		05D8 05BC
FB39		05D9 05BC
FB3A		05DA 05BC
FB3B		05DB 05BC
FB3C		05DC 05BC
FB3E		05DE 05BC
FB40		05E0 05BC
FB41		05E1 05BC
FB43		05E3 05BC
FB44		05E4 05BC
FB46		05E6 05BC
FB47		05E7 05BC
FB48		05E8 05BC
FB49		05E9 05BC
FB4A		05EA 05BC
FB4B		05D5 05B9
FB4C		05D1 05BF
FB4D		05DB 05BF
FB4E		05E4 05BF
FB4F		<compat> 05D0 05DC
FB50		<isolated> 0671
FB51		<final> 0671
FB52		<isolated> 067B
FB53		<final> 067B
FB54		<initial> 067B
FB55		<medial> 067B
FB56		<isolated> 067E
FB57		<final> 067E
FB58		<initial> 067E
FB59		<medial> 067E
FB5A		<isolated> 0680
FB5B		<final> 0680
FB5C		<initial> 0680
FB5D		<medial> 0680
FB5E		<isolated> 067A
FB5F		<final> 067A
FB60		<initial> 067A
FB61		<medial> 067A
FB62		<isolated> 067F
FB63		<final> 067F
FB64		<initial> 067F
FB65		<medial> 067F
FB66		<isolated> 0679
FB67		<final> 0679
FB68		<initial> 0679
FB69		<medial> 0679
FB6A		<isolated> 06A4
FB6B		<final> 06A4
FB6C		<initial> 06A4
FB6D		<medial> 06A4
FB6E		<isolated> 06A6
FB6F		<final> 06A6
FB70		<initial> 06A6
FB71		<medial> 06A6
FB72		<isolated> 0684
FB73		<final> 0684
FB74		<initial> 0684
FB75		<medial> 0684
FB76		<isolated> 0683
FB77		<final> 0683
FB78		<initial> 0683
FB79		<medial> 0683
FB7A		<isolated> 0686
FB7B		<final> 0686
FB7C		<initial> 0686
FB7D		<medial> 0686
FB7E		<isolated> 0687
FB7F		<final> 0687
FB80		<initial> 0687
FB81		<medial> 0687
FB82		<isolated> 068D
FB83		<final> 068D
FB84		<isolated> 068C
FB85		<final> 068C
FB86		<isolated> 068E
FB87		<final> 068E
FB88		<isolated> 0688
FB89		<final> 0688
FB8A		<isolated> 0698
FB8B		<final> 0698
FB8C		<isolated> 0691
FB8D		<final> 0691
FB8E		<isolated> 06A9
FB8F		<final> 06A9
FB90		<initial> 06A9
FB91		<medial> 06A9
FB92		<isolated> 06AF
FB93		<final> 06AF
FB94		<initial> 06AF
FB95		<medial> 06AF
FB96		<isolated> 06B3
FB97		<final> 06B3
FB98		<initial> 06B3
FB99		<medial> 06B3
FB9A		<isolated> 06B1
FB9B		<final> 06B1
FB9C		<initial> 06B1
FB9D		<medial> 06B1
FB9E		<isolated> 06BA
FB9F		<final> 06BA
FBA0		<isolated> 06BB
FBA1		<final> 06BB
FBA2		<initial> 06BB
FBA3		<medial> 06BB
FBA4		<isolated> 06C0
FBA5		<final> 06C0
FBA6		<isolated> 06C1
FBA7		<final> 06C1
FBA8		<initial> 06C1
FBA9		<medial> 06C1
FBAA		<isolated> 06BE
FBAB		<final> 06BE
FBAC		<initial> 06BE
FBAD		<medial> 06BE
FBAE		<isolated> 06D2
FBAF		<final> 06D2
FBB0		<isolated> 06D3
FBB1		<final> 06D3
FBD3		<isolated> 06AD
FBD4		<final> 06AD
FBD5		<initial> 06AD
FBD6		<medial> 06AD
FBD7		<isolated> 06C7
FBD8		<final> 06C7
FBD9		<isolated> 06C6
FBDA		<final> 06C6
FBDB		<isolated> 06C8
FBDC		<final> 06C8
FBDD		<isolated> 0677
FBDE		<isolated> 06CB
FBDF		<final> 06CB
FBE0		<isolated> 06C5
FBE1		<final> 06C5
FBE2		<isolated> 06C9
FBE3		<final> 06C9
FBE4		<isolated> 06D0
FBE5		<final> 06D0
FBE6		<initial> 06D0
FBE7		<medial> 06D0
FBE8		<initial> 0649
FBE9		<medial> 0649
FBEA		<isolated> 0626 0627
FBEB		<final> 0626 0627
FBEC		<isolated> 0626 06D5
FBED		<final> 0626 06D5
FBEE		<isolated> 0626 0648
FBEF		<final> 0626 0648
FBF0		<isolated> 0626 06C7
FBF1		<final> 0626 06C7
FBF2		<isolated> 0626 06C6
FBF3		<final> 0626 06C6
FBF4		<isolated> 0626 06C8
FBF5		<final> 0626 06C8
FBF6		<isolated> 0626 06D0
FBF7		<final> 0626 06D0
FBF8		<initial> 0626 06D0
FBF9		<isolated> 0626 0649
FBFA		<final> 0626 0649
FBFB		<initial> 0626 0649
FBFC		<isolated> 06CC
FBFD		<final> 06CC
FBFE		<initial> 06CC
FBFF		<medial> 06CC
FC00		<isolated> 0626 062C
FC01		<isolated> 0626 062D
FC02		<isolated> 0626 0645
FC03		<isolated> 0626 0649
FC04		<isolated> 0626 064A
FC05		<isolated> 0628 062C
FC06		<isolated> 0628 062D
FC07		<isolated> 0628 062E
FC08		<isolated> 0628 0645
FC09		<isolated> 0628 0649
FC0A		<isolated> 0628 064A
FC0B		<isolated> 062A 062C
FC0C		<isolated> 062A 062D
FC0D		<isolated> 062A 062E
FC0E		<isolated> 062A 0645
FC0F		<isolated> 062A 0649
FC10		<isolated> 062A 064A
FC11		<isolated> 062B 062C
FC12		<isolated> 062B 0645
FC13		<isolated> 062B 0649
FC14		<isolated> 062B 064A
FC15		<isolated> 062C 062D
FC16		<isolated> 062C 0645
FC17		<isolated> 062D 062C
FC18		<isolated> 062D 0645
FC19		<isolated> 062E 062C
FC1A		<isolated> 062E 062D
FC1B		<isolated> 062E 0645
FC1C		<isolated> 0633 062C
FC1D		<isolated> 0633 062D
FC1E		<isolated> 0633 062E
FC1F		<isolated> 0633 0645
FC20		<isolated> 0635 062D
FC21		<isolated> 0635 0645
FC22		<isolated> 0636 062C
FC23		<isolated> 0636 062D
FC24		<isolated> 0636 062E
FC25		<isolated> 0636 0645
FC26		<isolated> 0637 062D
FC27		<isolated> 0637 0645
FC28		<isolated> 0638 0645
FC29		<isolated> 0639 062C
FC2A		<isolated> 0639 0645
FC2B		<isolated> 063A 062C
FC2C		<isolated> 063A 0645
FC2D		<isolated> 0641 062C
FC2E		<isolated> 0641 062D
FC2F		<isolated> 0641 062E
FC30		<isolated> 0641 0645
FC31		<isolated> 0641 0649
FC32		<isolated> 0641 064A
FC33		<isolated> 0642 062D
FC34		<isolated> 0642 0645
FC35		<isolated> 0642 0649
FC36		<isolated> 0642 064A
FC37		<isolated> 0643 0627
FC38		<isolated> 0643 062C
FC39		<isolated> 0643 062D
FC3A		<isolated> 0643 062E
FC3B		<isolated> 0643 0644
FC3C		<isolated> 0643 0645
FC3D		<isolated> 0643 0649
FC3E		<isolated> 0643 064A
FC3F		<isolated> 0644 062C
FC40		<isolated> 0644 062D
FC41		<isolated> 0644 062E
FC42		<isolated> 0644 0645
FC43		<isolated> 0644 0649
FC44		<isolated> 0644 064A
FC45		<isolated> 0645 062C
FC46		<isolated> 0645 062D
FC47		<isolated> 0645 062E
FC48		<isolated> 0645 0645
FC49		<isolated> 0645 0649
FC4A		<isolated> 0645 064A
FC4B		<isolated> 0646 062C
FC4C		<isolated> 0646 062D
FC4D		<isolated> 0646 062E
FC4E		<isolated> 0646 0645
FC4F		<isolated> 0646 0649
FC50		<isolated> 0646 064A
FC51		<isolated> 0647 062C
FC52		<isolated> 0647 0645
FC53		<isolated> 0647 0649
FC54		<isolated> 0647 064A
FC55		<isolated> 064A 062C
FC56		<isolated> 064A 062D
FC57		<isolated> 064A 062E
FC58		<isolated> 064A 0645
FC59		<isolated> 064A 0649
FC5A		<isolated> 064A 064A
FC5B		<isolated> 0630 0670
FC5C		<isolated> 0631 0670
FC5D		<isolated> 0649 0670
FC5E		<isolated> 0020 064C 0651
FC5F		<isolated> 0020 064D 0651
FC60		<isolated> 0020 064E 0651
FC61		<isolated> 0020 064F 0651
FC62		<isolated> 0020 0650 0651
FC63		<isolated> 0020 0651 0670
FC64		<final> 0626 0631
FC65		<final> 0626 0632
FC66		<final> 0626 0645
FC67		<final> 0626 0646
FC68		<final> 0626 0649
FC69		<final> 0626 064A
FC6A		<final> 0628 0631
FC6B		<final> 0628 0632
FC6C		<final> 0628 0645
FC6D		<final> 0628 0646
FC6E		<final> 0628 0649
FC6F		<final> 0628 064A
FC70		<final> 062A 0631
FC71		<final> 062A 0632
FC72		<final> 062A 0645
FC73		<final> 062A 0646
FC74		<final> 062A 0649
FC75		<final> 062A 064A
FC76		<final> 062B 0631
FC77		<final> 062B 0632
FC78		<final> 062B 0645
FC79		<final> 062B 0646
FC7A		<final> 062B 0649
FC7B		<final> 062B 064A
FC7C		<final> 0641 0649
FC7D		<final> 0641 064A
FC7E		<final> 0642 0649
FC7F		<final> 0642 064A
FC80		<final> 0643 0627
FC81		<final> 0643 0644
FC82		<final> 0643 0645
FC83		<final> 0643 0649
FC84		<final> 0643 064A
FC85		<final> 0644 0645
FC86		<final> 0644 0649
FC87		<final> 0644 064A
FC88		<final> 0645 0627
FC89		<final> 0645 0645
FC8A		<final> 0646 0631
FC8B		<final> 0646 0632
FC8C		<final> 0646 0645
FC8D		<final> 0646 0646
FC8E		<final> 0646 0649
FC8F		<final> 0646 064A
FC90		<final> 0649 0670
FC91		<final> 064A 0631
FC92		<final> 064A 0632
FC93		<final> 064A 0645
FC94		<final> 064A 0646
FC95		<final> 064A 0649
FC96		<final> 064A 064A
FC97		<initial> 0626 062C
FC98		<initial> 0626 062D
FC99		<initial> 0626 062E
FC9A		<initial> 0626 0645
FC9B		<initial> 0626 0647
FC9C		<initial> 0628 062C
FC9D		<initial> 0628 062D
FC9E		<initial> 0628 062E
FC9F		<initial> 0628 0645
FCA0		<initial> 0628 0647
FCA1		<initial> 062A 062C
FCA2		<initial> 062A 062D
FCA3		<initial> 062A 062E
FCA4		<initial> 062A 0645
FCA5		<initial> 062A 0647
FCA6		<initial> 062B 0645
FCA7		<initial> 062C 062D
FCA8		<initial> 062C 0645
FCA9		<initial> 062D 062C
FCAA		<initial> 062D 0645
FCAB		<initial> 062E 062C
FCAC		<initial> 062E 0645
FCAD		<initial> 0633 062C
FCAE		<initial> 0633 062D
FCAF		<initial> 0633 062E
FCB0		<initial> 0633 0645
FCB1		<initial> 0635 062D
FCB2		<initial> 0635 062E
FCB3		<initial> 0635 0645
FCB4		<initial> 0636 062C
FCB5		<initial> 0636 062D
FCB6		<initial> 0636 062E
FCB7		<initial> 0636 0645
FCB8		<initial> 0637 062D
FCB9		<initial> 0638 0645
FCBA		<initial> 0639 062C
FCBB		<initial> 0639 0645
FCBC		<initial> 063A 062C
FCBD		<initial> 063A 0645
FCBE		<initial> 0641 062C
FCBF		<initial> 0641 062D
FCC0		<initial> 0641 062E
FCC1		<initial> 0641 0645
FCC2		<initial> 0642 062D
FCC3		<initial> 0642 0645
FCC4		<initial> 0643 062C
FCC5		<initial> 0643 062D
FCC6		<initial> 0643 062E
FCC7		<initial> 0643 0644
FCC8		<initial> 0643 0645
FCC9		<initial> 0644 062C
FCCA		<initial> 0644 062D
FCCB		<initial> 0644 062E
FCCC		<initial> 0644 0645
FCCD		<initial> 0644 0647
FCCE		<initial> 0645 062C
FCCF		<initial> 0645 062D
FCD0		<initial> 0645 062E
FCD1		<initial> 0645 0645
FCD2		<initial> 0646 062C
FCD3		<initial> 0646 062D
FCD4		<initial> 0646 062E
FCD5		<initial> 0646 0645
FCD6		<initial> 0646 0647
FCD7		<initial> 0647 062C
FCD8		<initial> 0647 0645
FCD9		<initial> 0647 0670
FCDA		<initial> 064A 062C
FCDB		<initial> 064A 062D
FCDC		<initial> 064A 062E
FCDD		<initial> 064A 0645
FCDE		<initial> 064A 0647
FCDF		<medial> 0626 0645
FCE0		<medial> 0626 0647
FCE1		<medial> 0628 0645
FCE2		<medial> 0628 0647
FCE3		<medial> 062A 0645
FCE4		<medial> 062A 0647
FCE5		<medial> 062B 0645
FCE6		<medial> 062B 0647
FCE7		<medial> 0633 0645
FCE8		<medial> 0633 0647
FCE9		<medial> 0634 0645
FCEA		<medial> 0634 0647
FCEB		<medial> 0643 0644
FCEC		<medial> 0643 0645
FCED		<medial> 0644 0645
FCEE		<medial> 0646 0645
FCEF		<medial> 0646 0647
FCF0		<medial> 064A 0645
FCF1		<medial> 064A 0647
FCF2		<medial> 0640 064E 0651
FCF3		<medial> 0640 064F 0651
FCF4		<medial> 0640 0650 0651
FCF5		<isolated> 0637 0649
FCF6		<isolated> 0637 064A
FCF7		<isolated> 0639 0649
FCF8		<isolated> 0639 064A
FCF9		<isolated> 063A 0649
FCFA		<isolated> 063A 064A
FCFB		<isolated> 0633 0649
FCFC		<isolated> 0633 064A
FCFD		<isolated> 0634 0649
FCFE		<isolated> 0634 064A
FCFF		<isolated> 062D 0649
FD00		<isolated> 062D 064A
FD01		<isolated> 062C 0649
FD02		<isolated> 062C 064A
FD03		<isolated> 062E 0649
FD04		<isolated> 062E 064A
FD05		<isolated> 0635 0649
FD06		<isolated> 0635 064A
FD07		<isolated> 0636 0649
FD08		<isolated> 0636 064A
FD09		<isolated> 0634 062C
FD0A		<isolated> 0634 062D
FD0B		<isolated> 0634 062E
FD0C		<isolated> 0634 0645
FD0D		<isolated> 0634 0631
FD0E		<isolated> 0633 0631
FD0F		<isolated> 0635 0631
FD10		<isolated> 0636 0631
FD11		<final> 0637 0649
FD12		<final> 0637 064A
FD13		<final> 0639 0649
FD14		<final> 0639 064A
FD15		<final> 063A 0649
FD16		<final> 063A 064A
FD17		<final> 0633 0649
FD18		<final> 0633 064A
FD19		<final> 0634 0649
FD1A		<final> 0634 064A
FD1B		<final> 062D 0649
FD1C		<final> 062D 064A
FD1D		<final> 062C 0649
FD1E		<final> 062C 064A
FD1F		<final> 062E 0649
FD20		<final> 062E 064A
FD21		<final> 0635 0649
FD22		<final> 0635 064A
FD23		<final> 0636 0649
FD24		<final> 0636 064A
FD25		<final> 0634 062C
FD26		<final> 0634 062D
FD27		<final> 0634 062E
FD28		<final> 0634 0645
FD29		<final> 0634 0631
FD2A		<final> 0633 0631
FD2B		<final> 0635 0631
FD2C		<final> 0636 0631
FD2D		<initial> 0634 062C
FD2E		<initial> 0634 062D
FD2F		<initial> 0634 062E
FD30		<initial> 0634 0645
FD31		<initial> 0633 0647
FD32		<initial> 0634 0647
FD33		<initial> 0637 0645
FD34		<medial> 0633 062C
FD35		<medial> 0633 062D
FD36		<medial> 0633 062E
FD37		<medial> 0634 062C
FD38		<medial> 0634 062D
FD39		<medial> 0634 062E
FD3A		<medial> 0637 0645
FD3B		<medial> 0638 0645
FD3C		<final> 0627 064B
FD3D		<isolated> 0627 064B
FD50		<initial> 062A 062C 0645
FD51		<final> 062A 062D 062C
FD52		<initial> 062A 062D 062C
FD53		<initial> 062A 062D 0645
FD54		<initial> 062A 062E 0645
FD55		<initial> 062A 0645 062C
FD56		<initial> 062A 0645 062D
FD57		<initial> 062A 0645 062E
FD58		<final> 062C 0645 062D
FD59		<initial> 062C 0645 062D
FD5A		<final> 062D 0645 064A
FD5B		<final> 062D 0645 0649
FD5C		<initial> 0633 062D 062C
FD5D		<initial> 0633 062C 062D
FD5E		<final> 0633 062C 0649
FD5F		<final> 0633 0645 062D
FD60		<initial> 0633 0645 062D
FD61		<initial> 0633 0645 062C
FD62		<final> 0633 0645 0645
FD63		<initial> 0633 0645 0645
FD64		<final> 0635 062D 062D
FD65		<initial> 0635 062D 062D
FD66		<final> 0635 0645 0645
FD67		<final> 0634 062D 0645
FD68		<initial> 0634 062D 0645
FD69		<final> 0634 062C 064A
FD6A		<final> 0634 0645 062E
FD6B		<initial> 0634 0645 062E
FD6C		<final> 0634 0645 0645
FD6D		<initial> 0634 0645 0645
FD6E		<final> 0636 062D 0649
FD6F		<final> 0636 062E 0645
FD70		<initial> 0636 062E 0645
FD71		<final> 0637 0645 062D
FD72		<initial> 0637 0645 062D
FD73		<initial> 0637 0645 0645
FD74		<final> 0637 0645 064A
FD75		<final> 0639 062C 0645
FD76		<final> 0639 0645 0645
FD77		<initial> 0639 0645 0645
FD78		<final> 0639 0645 0649
FD79		<final> 063A 0645 0645
FD7A		<final> 063A 0645 064A
FD7B		<final> 063A 0645 0649
FD7C		<final> 0641 062E 0645
FD7D		<initial> 0641 062E 0645
FD7E		<final> 0642 0645 062D
FD7F		<final> 0642 0645 0645
FD80		<final> 0644 062D 0645
FD81		<final> 0644 062D 064A
FD82		<final> 0644 062D 0649
FD83		<initial> 0644 062C 062C
FD84		<final> 0644 062C 062C
FD85		<final> 0644 062E 0645
FD86		<initial> 0644 062E 0645
FD87		<final> 0644 0645 062D
FD88		<initial> 0644 0645 062D
FD89		<initial> 0645 062D 062C
FD8A		<initial> 0645 062D 0645
FD8B		<final> 0645 062D 064A
FD8C		<initial> 0645 062C 062D
FD8D		<initial> 0645 062C 0645
FD8E		<initial> 0645 062E 062C
FD8F		<initial> 0645 062E 0645
FD92		<initial> 0645 062C 062E
FD93		<initial> 0647 0645 062C
FD94		<initial> 0647 0645 0645
FD95		<initial> 0646 062D 0645
FD96		<final> 0646 062D 0649
FD97		<final> 0646 062C 0645
FD98		<initial> 0646 062C 0645
FD99		<final> 0646 062C 0649
FD9A		<final> 0646 0645 064A
FD9B		<final> 0646 0645 0649
FD9C		<final> 064A 0645 0645
FD9D		<initial> 064A 0645 0645
FD9E		<final> 0628 062E 064A
FD9F		<final> 062A 062C 064A
FDA0		<final> 062A 062C 0649
FDA1		<final> 062A 062E 064A
FDA2		<final> 062A 062E 0649
FDA3		<final> 062A 0645 064A
FDA4		<final> 062A 0645 0649
FDA5		<final> 062C 0645 064A
FDA6		<final> 062C 062D 0649
FDA7		<final> 062C 0645 0649
FDA8		<final> 0633 062E 0649
FDA9		<final> 0635 062D 064A
FDAA		<final> 0634 062D 064A
FDAB		<final> 0636 062D 064A
FDAC		<final> 0644 062C 064A
FDAD		<final> 0644 0645 064A
FDAE		<final> 064A 062D 064A
FDAF		<final> 064A 062C 064A
FDB0		<final> 064A 0645 064A
FDB1		<final> 0645 0645 064A
FDB2		<final> 0642 0645 064A
FDB3		<final> 0646 062D 064A
FDB4		<initial> 0642 0645 062D
FDB5		<initial> 0644 062D 0645
FDB6		<final> 0639 0645 064A
FDB7		<final> 0643 0645 064A
FDB8		<initial> 0646 062C 062D
FDB9		<final> 0645 062E 064A
FDBA		<initial> 0644 062C 0645
FDBB		<final> 0643 0645 0645
FDBC		<final> 0644 062C 0645
FDBD		<final> 0646 062C 062D
FDBE		<final> 062C 062D 064A
FDBF		<final> 062D 062C 064A
FDC0		<final> 0645 062C 064A
FDC1		<final> 0641 0645 064A
FDC2		<final> 0628 062D 064A
FDC3		<initial> 0643 0645 0645
FDC4		<initial> 0639 062C 0645
FDC5		<initial> 0635 0645 0645
FDC6		<final> 0633 062E 064A
FDC7		<final> 0646 062C 064A
FDF0		<isolated> 0635 0644 06D2
FDF1		<isolated> 0642 0644 06D2
FDF2		<isolated> 0627 0644 0644 0647
FDF3		<isolated> 0627 0643 0628 0631
FDF4		<isolated> 0645 062D 0645 062F
FDF5		<isolated> 0635 0644 0639 0645
FDF6		<isolated> 0631 0633 0648 0644
FDF7		<isolated> 0639 0644 064A 0647
FDF8		<isolated> 0648 0633 0644 0645
FDF9		<isolated> 0635 0644 0649
FDFA		<isolated> 0635 0644 0649 0020 0627 0644 0644 0647 0020 0639 0644 064A 0647 0020 0648 0633 0644 0645
FDFB		<isolated> 062C 0644 0020 062C 0644 0627 0644 0647
FDFC		<isolated> 0631 06CC 0627 0644
FE10		<vertical> 002C
FE11		<vertical> 3001
FE12		<vertical> 3002
FE13		<vertical> 003A
FE14		<vertical> 003B
FE15		<vertical> 0021
FE16		<vertical> 003F
FE17		<vertical> 3016
FE18		<vertical> 3017
FE19		<vertical> 2026
FE30		<vertical> 2025
FE31		<vertical> 2014
FE32		<vertical> 2013
FE33	FE34	<vertical> 005F
FE35		<vertical> 0028
FE36		<vertical> 0029
FE37		<vertical> 007B
FE38		<vertical> 007D
FE39		<vertical> 3014
FE3A		<vertical> 3015
FE3B		<vertical> 3010
FE3C		<vertical> 3011
FE3D		<vertical> 300A
FE3E		<vertical> 300B
FE3F		<vertical> 3008
FE40		<vertical> 3009
FE41		<vertical> 300C
FE42		<vertical> 300D
FE43		<vertical> 300E
FE44		<vertical> 300F
FE47		<vertical> 005B
FE48		<vertical> 005D
FE49	FE4C	<compat> 203E
FE4D	FE4F	<compat> 005F
FE50		<small> 002C
FE51		<small> 3001
FE52		<small> 002E
FE54		<small> 003B
FE55		<small> 003A
FE56		<small> 003F
FE57		<small> 0021
FE58		<small> 2014
FE59		<small> 0028
FE5A		<small> 0029
FE5B		<small> 007B
FE5C		<small> 007D
FE5D		<small> 3014
FE5E		<small> 3015
FE5F		<small> 0023
FE60		<small> 0026
FE61		<small> 002A
FE62		<small> 002B
FE63		<small> 002D
FE64		<small> 003C
FE65		<small> 003E
FE66		<small> 003D
FE68		<small> 005C
FE69		<small> 0024
FE6A		<small> 0025
FE6B		<small> 0040
FE70		<isolated> 0020 064B
FE71		<medial> 0640 064B
FE72		<isolated> 0020 064C
FE74		<isolated> 0020 064D
FE76		<isolated> 0020 064E
FE77		<medial> 0640 064E
FE78		<isolated> 0020 064F
FE79		<medial> 0640 064F
FE7A		<isolated> 0020 0650
FE7B		<medial> 0640 0650
FE7C		<isolated> 0020 0651
FE7D		<medial> 0640 0651
FE7E		<isolated> 0020 0652
FE7F		<medial> 0640 0652
FE80		<isolated> 0621
FE81		<isolated> 0622
FE82		<final> 0622
FE83		<isolated> 0623
FE84		<final> 0623
FE85		<isolated> 0624
FE86		<final> 0624
FE87		<isolated> 0625
FE88		<final> 0625
FE89		<isolated> 0626
FE8A		<final> 0626
FE8B		<initial> 0626
FE8C		<medial> 0626
FE8D		<isolated> 0627
FE8E		<final> 0627
FE8F		<isolated> 0628
FE90		<final> 0628
FE91		<initial> 0628
FE92		<medial> 0628
FE93		<isolated> 0629
FE94		<final> 0629
FE95		<isolated> 062A
FE96		<final> 062A
FE97		<initial> 062A
FE98		<medial> 062A
FE99		<isolated> 062B
FE9A		<final> 062B
FE9B		<initial> 062B
FE9C		<medial> 062B
FE9D		<isolated> 062C
FE9E		<final> 062C
FE9F		<initial> 062C
FEA0		<medial> 062C
FEA1		<isolated> 062D
FEA2		<final> 062D
FEA3		<initial> 062D
FEA4		<medial> 062D
FEA5		<isolated> 062E
FEA6		<final> 062E
FEA7		<initial> 062E
FEA8		<medial> 062E
FEA9		<isolated> 062F
FEAA		<final> 062F
FEAB		<isolated> 0630
FEAC		<final> 0630
FEAD		<isolated> 0631
FEAE		<final> 0631
FEAF		<isolated> 0632
FEB0		<final> 0632
FEB1		<isolated> 0633
FEB2		<final> 0633
FEB3		<initial> 0633
FEB4		<medial> 0633
FEB5		<isolated> 0634
FEB6		<final> 0634
FEB7		<initial> 0634
FEB8		<medial> 0634
FEB9		<isolated> 0635
FEBA		<final> 0635
FEBB		<initial> 0635
FEBC		<medial> 0635
FEBD		<isolated> 0636
FEBE		<final> 0636
FEBF		<initial> 0636
FEC0		<medial> 0636
FEC1		<isolated> 0637
FEC2		<final> 0637
FEC3		<initial> 0637
FEC4		<medial> 0637
FEC5		<isolated> 0638
FEC6		<final> 0638
FEC7		<initial> 0638
FEC8		<medial> 0638
FEC9		<isolated> 0639
FECA		<final> 0639
FECB		<initial> 0639
FECC		<medial> 0639
FECD		<isolated> 063A
FECE		<final> 063A
FECF		<initial> 063A
FED0		<medial> 063A
FED1		<isolated> 0641
FED2		<final> 0641
FED3		<initial> 0641
FED4		<medial> 0641
FED5		<isolated> 0642
FED6		<final> 0642
FED7		<initial> 0642
FED8		<medial> 0642
FED9		<isolated> 0643
FEDA		<final> 0643
FEDB		<initial> 0643
FEDC		<medial> 0643
FEDD		<isolated> 0644
FEDE		<final> 0644
FEDF		<initial> 0644
FEE0		<medial> 0644
FEE1		<isolated> 0645
FEE2		<final> 0645
FEE3		<initial> 0645
FEE4		<medial> 0645
FEE5		<isolated> 0646
FEE6		<final> 0646
FEE7		<initial> 0646
FEE8		<medial> 0646
FEE9		<isolated> 0647
FEEA		<final> 0647
FEEB		<initial> 0647
FEEC		<medial> 0647
FEED		<isolated> 0648
FEEE		<final> 0648
FEEF		<isolated> 0649
FEF0		<final> 0649
FEF1		<isolated> 064A
FEF2		<final> 064A
FEF3		<initial> 064A
FEF4		<medial> 064A
FEF5		<isolated> 0644 0622
FEF6		<final> 0644 0622
FEF7		<isolated> 0644 0623
FEF8		<final> 0644 0623
FEF9		<isolated> 0644 0625
FEFA		<final> 0644 0625
FEFB		<isolated> 0644 0627
FEFC		<final> 0644 0627
FF01		<wide> 0021
FF02		<wide> 0022
FF03		<wide> 0023
FF04		<wide> 0024
FF05		<wide> 0025
FF06		<wide> 0026
FF07		<wide> 0027
FF08		<wide> 0028
FF09		<wide> 0029
FF0A		<wide> 002A
FF0B		<wide> 002B
FF0C		<wide> 002C
FF0D		<wide> 002D
FF0E		<wide> 002E
FF0F		<wide> 002F
FF10		<wide> 0030
FF11		<wide> 0031
FF12		<wide> 0032
FF13		<wide> 0033
FF14		<wide> 0034
FF15		<wide> 0035
FF16		<wide> 0036
FF17		<wide> 0037
FF18		<wide> 0038
FF19		<wide> 0039
FF1A		<wide> 003A
FF1B		<wide> 003B
FF1C		<wide> 003C
FF1D		<wide> 003D
FF1E		<wide> 003E
FF1F		<wide> 003F
FF20		<wide> 0040
FF21		<wide> 0041
FF22		<wide> 0042
FF23		<wide> 0043
FF24		<wide> 0044
FF25		<wide> 0045
FF26		<wide> 0046
FF27		<wide> 0047
FF28		<wide> 0048
FF29		<wide> 0049
FF2A		<wide> 004A
FF2B		<wide> 004B
FF2C		<wide> 004C
FF2D		<wide> 004D
FF2E		<wide> 004E
FF2F		<wide> 004F
FF30		<wide> 0050
FF31		<wide> 0051
FF32		<wide> 0052
FF33		<wide> 0053
FF34		<wide> 0054
FF35		<wide> 0055
FF36		<wide> 0056
FF37		<wide> 0057
FF38		<wide> 0058
FF39		<wide> 0059
FF3A		<wide> 005A
FF3B		<wide> 005B
FF3C		<wide> 005C
FF3D		<wide> 005D
FF3E		<wide> 005E
FF3F		<wide> 005F
FF40		<wide> 0060
FF41		<wide> 0061
FF42		<wide> 0062
FF43		<wide> 0063
FF44		<wide> 0064
FF45		<wide> 0065
FF46		<wide> 0066
FF47		<wide> 0067
FF48		<wide> 0068
FF49		<wide> 0069
FF4A		<wide> 006A
FF4B		<wide> 006B
FF4C		<wide> 006C
FF4D		<wide> 006D
FF4E		<wide> 006E
FF4F		<wide> 006F
FF50		<wide> 0070
FF51		<wide> 0071
FF52		<wide> 0072
FF53		<wide> 0073
FF54		<wide> 0074
FF55		<wide> 0075
FF56		<wide> 0076
FF57		<wide> 0077
FF58		<wide> 0078
FF59		<wide> 0079
FF5A		<wide> 007A
FF5B		<wide> 007B
FF5C		<wide> 007C
FF5D		<wide> 007D
FF5E		<wide> 007E
FF5F		<wide> 2985
FF60		<wide> 2986
FF61		<narrow> 3002
FF62		<narrow> 300C
FF63		<narrow> 300D
FF64		<narrow> 3001
FF65		<narrow> 30FB
FF66		<narrow> 30F2
FF67		<narrow> 30A1
FF68		<narrow> 30A3
FF69		<narrow> 30A5
FF6A		<narrow> 30A7
FF6B		<narrow> 30A9
FF6C		<narrow> 30E3
FF6D		<narrow> 30E5
FF6E		<narrow> 30E7
FF6F		<narrow> 30C3
FF70		<narrow> 30FC
FF71		<narrow> 30A2
FF72		<narrow> 30A4
FF73		<narrow> 30A6
FF74		<narrow> 30A8
FF75		<narrow> 30AA
FF76		<narrow> 30AB
FF77		<narrow> 30AD
FF78		<narrow> 30AF
FF79		<narrow> 30B1
FF7A		<narrow> 30B3
FF7B		<narrow> 30B5
FF7C		<narrow> 30B7
FF7D		<narrow> 30B9
FF7E		<narrow> 30BB
FF7F		<narrow> 30BD
FF80		<narrow> 30BF
FF81		<narrow> 30C1
FF82		<narrow> 30C4
FF83		<narrow> 30C6
FF84		<narrow> 30C8
FF85		<narrow> 30CA
FF86		<narrow> 30CB
FF87		<narrow> 30CC
FF88		<narrow> 30CD
FF89		<narrow> 30CE
FF8A		<narrow> 30CF
FF8B		<narrow> 30D2
FF8C		<narrow> 30D5
FF8D		<narrow> 30D8
FF8E		<narrow> 30DB
FF8F		<narrow> 30DE
FF90		<narrow> 30DF
FF91		<narrow> 30E0
FF92		<narrow> 30E1
FF93		<narrow> 30E2
FF94		<narrow> 30E4
FF95		<narrow> 30E6
FF96		<narrow> 30E8
FF97		<narrow> 30E9
FF98		<narrow> 30EA
FF99		<narrow> 30EB
FF9A		<narrow> 30EC
FF9B		<narrow> 30ED
FF9C		<narrow> 30EF
FF9D		<narrow> 30F3
FF9E		<narrow> 3099
FF9F		<narrow> 309A
FFA0		<narrow> 3164
FFA1		<narrow> 3131
FFA2		<narrow> 3132
FFA3		<narrow> 3133
FFA4		<narrow> 3134
FFA5		<narrow> 3135
FFA6		<narrow> 3136
FFA7		<narrow> 3137
FFA8		<narrow> 3138
FFA9		<narrow> 3139
FFAA		<narrow> 313A
FFAB		<narrow> 313B
FFAC		<narrow> 313C
FFAD		<narrow> 313D
FFAE		<narrow> 313E
FFAF		<narrow> 313F
FFB0		<narrow> 3140
FFB1		<narrow> 3141
FFB2		<narrow> 3142
FFB3		<narrow> 3143
FFB4		<narrow> 3144
FFB5		<narrow> 3145
FFB6		<narrow> 3146
FFB7		<narrow> 3147
FFB8		<narrow> 3148
FFB9		<narrow> 3149
FFBA		<narrow> 314A
FFBB		<narrow> 314B
FFBC		<narrow> 314C
FFBD		<narrow> 314D
FFBE		<narrow> 314E
FFC2		<narrow> 314F
FFC3		<narrow> 3150
FFC4		<narrow> 3151
FFC5		<narrow> 3152
FFC6		<narrow> 3153
FFC7		<narrow> 3154
FFCA		<narrow> 3155
FFCB		<narrow> 3156
FFCC		<narrow> 3157
FFCD		<narrow> 3158
FFCE		<narrow> 3159
FFCF		<narrow> 315A
FFD2		<narrow> 315B
FFD3		<narrow> 315C
FFD4		<narrow> 315D
FFD5		<narrow> 315E
FFD6		<narrow> 315F
FFD7		<narrow> 3160
FFDA		<narrow> 3161
FFDB		<narrow> 3162
FFDC		<narrow> 3163
FFE0		<wide> 00A2
FFE1		<wide> 00A3
FFE2		<wide> 00AC
FFE3		<wide> 00AF
FFE4		<wide> 00A6
FFE5		<wide> 00A5
FFE6		<wide> 20A9
FFE8		<narrow> 2502
FFE9		<narrow> 2190
FFEA		<narrow> 2191
FFEB		<narrow> 2192
FFEC		<narrow> 2193
FFED		<narrow> 25A0
FFEE		<narrow> 25CB
10781		<super> 02D0
10782		<super> 02D1
10783		<super> 00E6
10784		<super> 0299
10785		<super> 0253
10787		<super> 02A3
10788		<super> AB66
10789		<super> 02A5
1078A		<super> 02A4
1078B		<super> 0256
1078C		<super> 0257
1078D		<super> 1D91
1078E		<super> 0258
1078F		<super> 025E
10790		<super> 02A9
10791		<super> 0264
10792		<super> 0262
10793		<super> 0260
10794		<super> 029B
10795		<super> 0127
10796		<super> 029C
10797		<super> 0267
10798		<super> 0284
10799		<super> 02AA
1079A		<super> 02AB
1079B		<super> 026C
1079C		<super> 1DF04
1079D		<super> A78E
1079E		<super> 026E
1079F		<super> 1DF05
107A0		<super> 028E
107A1		<super> 1DF06
107A2		<super> 00F8
107A3		<super> 0276
107A4		<super> 0277
107A5		<super> 0071
107A6		<super> 027A
107A7		<super> 1DF08
107A8		<super> 027D
107A9		<super> 027E
107AA		<super> 0280
107AB		<super> 02A8
107AC		<super> 02A6
107AD		<super> AB67
107AE		<super> 02A7
107AF		<super> 0288
107B0		<super> 2C71
107B2		<super> 028F
107B3		<super> 02A1
107B4		<super> 02A2
107B5		<super> 0298
107B6		<super> 01C0
107B7		<super> 01C1
107B8		<super> 01C2
107B9		<super> 1DF0A
107BA		<super> 1DF1E
1109A		11099 110BA
1109C		1109B 110BA
110AB		110A5 110BA
1112E		11131 11127
1112F		11132 11127
1134B		11347 1133E
1134C		11347 11357
114BB		114B9 114BA
114BC		114B9 114B0
114BE		114B9 114BD
115BA		115B8 115AF
115BB		115B9 115AF
11938		11935 11930
1D15E		1D157 1D165
1D15F		1D158 1D165
1D160		1D15F 1D16E
1D161		1D15F 1D16F
1D162		1D15F 1D170
1D163		1D15F 1D171
1D164		1D15F 1D172
1D1BB		1D1B9 1D165
1D1BC		1D1BA 1D165
1D1BD		1D1BB 1D16E
1D1BE		1D1BC 1D16E
1D1BF		1D1BB 1D16F
1D1C0		1D1BC 1D16F
1D400		<font> 0041
1D401		<font> 0042
1D402		<font> 0043
1D403		<font> 0044
1D404		<font> 0045
1D405		<font> 0046
1D406		<font> 0047
1D407		<font> 0048
1D408		<font> 0049
1D409		<font> 004A
1D40A		<font> 004B
1D40B		<font> 004C
1D40C		<font> 004D
1D40D		<font> 004E
1D40E		<font> 004F
1D40F		<font> 0050
1D410		<font> 0051
1D411		<font> 0052
1D412		<font> 0053
1D413		<font> 0054
1D414		<font> 0055
1D415		<font> 0056
1D416		<font> 0057
1D417		<font> 0058
1D418		<font> 0059
1D419		<font> 005A
1D41A		<font> 0061
1D41B		<font> 0062
1D41C		<font> 0063
1D41D		<font> 0064
1D41E		<font> 0065
1D41F		<font> 0066
1D420		<font> 0067
1D421		<font> 0068
1D422		<font> 0069
1D423		<font> 006A
1D424		<font> 006B
1D425		<font> 006C
1D426		<font> 006D
1D427		<font> 006E
1D428		<font> 006F
1D429		<font> 0070
1D42A		<font> 0071
1D42B		<font> 0072
1D42C		<font> 0073
1D42D		<font> 0074
1D42E		<font> 0075
1D42F		<font> 0076
1D430		<font> 0077
1D431		<font> 0078
1D432		<font> 0079
1D433		<font> 007A
1D434		<font> 0041
1D435		<font> 0042
1D436		<font> 0043
1D437		<font> 0044
1D438		<font> 0045
1D439		<font> 0046
1D43A		<font> 0047
1D43B		<font> 0048
1D43C		<font> 0049
1D43D		<font> 004A
1D43E		<font> 004B
1D43F		<font> 004C
1D440		<font> 004D
1D441		<font> 004E
1D442		<font> 004F
1D443		<font> 0050
1D444		<font> 0051
1D445		<font> 0052
1D446		<font> 0053
1D447		<font> 0054
1D448		<font> 0055
1D449		<font> 0056
1D44A		<font> 0057
1D44B		<font> 0058
1D44C		<font> 0059
1D44D		<font> 005A
1D44E		<font> 0061
1D44F		<font> 0062
1D450		<font> 0063
1D451		<font> 0064
1D452		<font> 0065
1D453		<font> 0066
1D454		<font> 0067
1D456		<font> 0069
1D457		<font> 006A
1D458		<font> 006B
1D459		<font> 006C
1D45A		<font> 006D
1D45B		<font> 006E
1D45C		<font> 006F
1D45D		<font> 0070
1D45E		<font> 0071
1D45F		<font> 0072
1D460		<font> 0073
1D461		<font> 0074
1D462		<font> 0075
1D463		<font> 0076
1D464		<font> 0077
1D465		<font> 0078
1D466		<font> 0079
1D467		<font> 007A
1D468		<font> 0041
1D469		<font> 0042
1D46A		<font> 0043
1D46B		<font> 0044
1D46C		<font> 0045
1D46D		<font> 0046
1D46E		<font> 0047
1D46F		<font> 0048
1D470		<font> 0049
1D471		<font> 004A
1D472		<font> 004B
1D473		<font> 004C
1D474		<font> 004D
1D475		<font> 004E
1D476		<font> 004F
1D477		<font> 0050
1D478		<font> 0051
1D479		<font> 0052
1D47A		<font> 0053
1D47B		<font> 0054
1D47C		<font> 0055
1D47D		<font> 0056
1D47E		<font> 0057
1D47F		<font> 0058
1D480		<font> 0059
1D481		<font> 005A
1D482		<font> 0061
1D483		<font> 0062
1D484		<font> 0063
1D485		<font> 0064
1D486		<font> 0065
1D487		<font> 0066
1D488		<font> 0067
1D489		<font> 0068
1D48A		<font> 0069
1D48B		<font> 006A
1D48C		<font> 006B
1D48D		<font> 006C
1D48E		<font> 006D
1D48F		<font> 006E
1D490		<font> 006F
1D491		<font> 0070
1D492		<font> 0071
1D493		<font> 0072
1D494		<font> 0073
1D495		<font> 0074
1D496		<font> 0075
1D497		<font> 0076
1D498		<font> 0077
1D499		<font> 0078
1D49A		<font> 0079
1D49B		<font> 007A
1D49C		<font> 0041
1D49E		<font> 0043
1D49F		<font> 0044
1D4A2		<font> 0047
1D4A5		<font> 004A
1D4A6		<font> 004B
1D4A9		<font> 004E
1D4AA		<font> 004F
1D4AB		<font> 0050
1D4AC		<font> 0051
1D4AE		<font> 0053
1D4AF		<font> 0054
1D4B0		<font> 0055
1D4B1		<font> 0056
1D4B2		<font> 0057
1D4B3		<font> 0058
1D4B4		<font> 0059
1D4B5		<font> 005A
1D4B6		<font> 0061
1D4B7		<font> 0062
1D4B8		<font> 0063
1D4B9		<font> 0064
1D4BB		<font> 0066
1D4BD		<font> 0068
1D4BE		<font> 0069
1D4BF		<font> 006A
1D4C0		<font> 006B
1D4C1		<font> 006C
1D4C2		<font> 006D
1D4C3		<font> 006E
1D4C5		<font> 0070
1D4C6		<font> 0071
1D4C7		<font> 0072
1D4C8		<font> 0073
1D4C9		<font> 0074
1D4CA		<font> 0075
1D4CB		<font> 0076
1D4CC		<font> 0077
1D4CD		<font> 0078
1D4CE		<font> 0079
1D4CF		<font> 007A
1D4D0		<font> 0041
1D4D1		<font> 0042
1D4D2		<font> 0043
1D4D3		<font> 0044
1D4D4		<font> 0045
1D4D5		<font> 0046
1D4D6		<font> 0047
1D4D7		<font> 0048
1D4D8		<font> 0049
1D4D9		<font> 004A
1D4DA		<font> 004B
1D4DB		<font> 004C
1D4DC		<font> 004D
1D4DD		<font> 004E
1D4DE		<font> 004F
1D4DF		<font> 0050
1D4E0		<font> 0051
1D4E1		<font> 0052
1D4E2		<font> 0053
1D4E3		<font> 0054
1D4E4		<font> 0055
1D4E5		<font> 0056
1D4E6		<font> 0057
1D4E7		<font> 0058
1D4E8		<font> 0059
1D4E9		<font> 005A
1D4EA		<font> 0061
1D4EB		<font> 0062
1D4EC		<font> 0063
1D4ED		<font> 0064
1D4EE		<font> 0065
1D4EF		<font> 0066
1D4F0		<font> 0067
1D4F1		<font> 0068
1D4F2		<font> 0069
1D4F3		<font> 006A
1D4F4		<font> 006B
1D4F5		<font> 006C
1D4F6		<font> 006D
1D4F7		<font> 006E
1D4F8		<font> 006F
1D4F9		<font> 0070
1D4FA		<font> 0071
1D4FB		<font> 0072
1D4FC		<font> 0073
1D4FD		<font> 0074
1D4FE		<font> 0075
1D4FF		<font> 0076
1D500		<font> 0077
1D501		<font> 0078
1D502		<font> 0079
1D503		<font> 007A
1D504		<font> 0041
1D505		<font> 0042
1D507		<font> 0044
1D508		<font> 0045
1D509		<font> 0046
1D50A		<font> 0047
1D50D		<font> 004A
1D50E		<font> 004B
1D50F		<font> 004C
1D510		<font> 004D
1D511		<font> 004E
1D512		<font> 004F
1D513		<font> 0050
1D514		<font> 0051
1D516		<font> 0053
1D517		<font> 0054
1D518		<font> 0055
1D519		<font> 0056
1D51A		<font> 0057
1D51B		<font> 0058
1D51C		<font> 0059
1D51E		<font> 0061
1D51F		<font> 0062
1D520		<font> 0063
1D521		<font> 0064
1D522		<font> 0065
1D523		<font> 0066
1D524		<font> 0067
1D525		<font> 0068
1D526		<font> 0069
1D527		<font> 006A
1D528		<font> 006B
1D529		<font> 006C
1D52A		<font> 006D
1D52B		<font> 006E
1D52C		<font> 006F
1D52D		<font> 0070
1D52E		<font> 0071
1D52F		<font> 0072
1D530		<font> 0073
1D531		<font> 0074
1D532		<font> 0075
1D533		<font> 0076
1D534		<font> 0077
1D535		<font> 0078
1D536		<font> 0079
1D537		<font> 007A
1D538		<font> 0041
1D539		<font> 0042
1D53B		<font> 0044
1D53C		<font> 0045
1D53D		<font> 0046
1D53E		<font> 0047
1D540		<font> 0049
1D541		<font> 004A
1D542		<font> 004B
1D543		<font> 004C
1D544		<font> 004D
1D546		<font> 004F
1D54A		<font> 0053
1D54B		<font> 0054
1D54C		<font> 0055
1D54D		<font> 0056
1D54E		<font> 0057
1D54F		<font> 0058
1D550		<font> 0059
1D552		<font> 0061
1D553		<font> 0062
1D554		<font> 0063
1D555		<font> 0064
1D556		<font> 0065
1D557		<font> 0066
1D558		<font> 0067
1D559		<font> 0068
1D55A		<font> 0069
1D55B		<font> 006A
1D55C		<font> 006B
1D55D		<font> 006C
1D55E		<font> 006D
1D55F		<font> 006E
1D560		<font> 006F
1D561		<font> 0070
1D562		<font> 0071
1D563		<font> 0072
1D564		<font> 0073
1D565		<font> 0074
1D566		<font> 0075
1D567		<font> 0076
1D568		<font> 0077
1D569		<font> 0078
1D56A		<font> 0079
1D56B		<font> 007A
1D56C		<font> 0041
1D56D		<font> 0042
1D56E		<font> 0043
1D56F		<font> 0044
1D570		<font> 0045
1D571		<font> 0046
1D572		<font> 0047
1D573		<font> 0048
1D574		<font> 0049
1D575		<font> 004A
1D576		<font> 004B
1D577		<font> 004C
1D578		<font> 004D
1D579		<font> 004E
1D57A		<font> 004F
1D57B		<font> 0050
1D57C		<font> 0051
1D57D		<font> 0052
1D57E		<font> 0053
1D57F		<font> 0054
1D580		<font> 0055
1D581		<font> 0056
1D582		<font> 0057
1D583		<font> 0058
1D584		<font> 0059
1D585		<font> 005A
1D586		<font> 0061
1D587		<font> 0062
1D588		<font> 0063
1D589		<font> 0064
1D58A		<font> 0065
1D58B		<font> 0066
1D58C		<font> 0067
1D58D		<font> 0068
1D58E		<font> 0069
1D58F		<font> 006A
1D590		<font> 006B
1D591		<font> 006C
1D592		<font> 006D
1D593		<font> 006E
1D594		<font> 006F
1D595		<font> 0070
1D596		<font> 0071
1D597		<font> 0072
1D598		<font> 0073
1D599		<font> 0074
1D59A		<font> 0075
1D59B		<font> 0076
1D59C		<font> 0077
1D59D		<font> 0078
1D59E		<font> 0079
1D59F		<font> 007A
1D5A0		<font> 0041
1D5A1		<font> 0042
1D5A2		<font> 0043
1D5A3		<font> 0044
1D5A4		<font> 0045
1D5A5		<font> 0046
1D5A6		<font> 0047
1D5A7		<font> 0048
1D5A8		<font> 0049
1D5A9		<font> 004A
1D5AA		<font> 004B
1D5AB		<font> 004C
1D5AC		<font> 004D
1D5AD		<font> 004E
1D5AE		<font> 004F
1D5AF		<font> 0050
1D5B0		<font> 0051
1D5B1		<font> 0052
1D5B2		<font> 0053
1D5B3		<font> 0054
1D5B4		<font> 0055
1D5B5		<font> 0056
1D5B6		<font> 0057
1D5B7		<font> 0058
1D5B8		<font> 0059
1D5B9		<font> 005A
1D5BA		<font> 0061
1D5BB		<font> 0062
1D5BC		<font> 0063
1D5BD		<font> 0064
1D5BE		<font> 0065
1D5BF		<font> 0066
1D5C0		<font> 0067
1D5C1		<font> 0068
1D5C2		<font> 0069
1D5C3		<font> 006A
1D5C4		<font> 006B
1D5C5		<font> 006C
1D5C6		<font> 006D
1D5C7		<font> 006E
1D5C8		<font> 006F
1D5C9		<font> 0070
1D5CA		<font> 0071
1D5CB		<font> 0072
1D5CC		<font> 0073
1D5CD		<font> 0074
1D5CE		<font> 0075
1D5CF		<font> 0076
1D5D0		<font> 0077
1D5D1		<font> 0078
1D5D2		<font> 0079
1D5D3		<font> 007A
1D5D4		<font> 0041
1D5D5		<font> 0042
1D5D6		<font> 0043
1D5D7		<font> 0044
1D5D8		<font> 0045
1D5D9		<font> 0046
1D5DA		<font> 0047
1D5DB		<font> 0048
1D5DC		<font> 0049
1D5DD		<font> 004A
1D5DE		<font> 004B
1D5DF		<font> 004C
1D5E0		<font> 004D
1D5E1		<font> 004E
1D5E2		<font> 004F
1D5E3		<font> 0050
1D5E4		<font> 0051
1D5E5		<font> 0052
1D5E6		<font> 0053
1D5E7		<font> 0054
1D5E8		<font> 0055
1D5E9		<font> 0056
1D5EA		<font> 0057
1D5EB		<font> 0058
1D5EC		<font> 0059
1D5ED		<font> 005A
1D5EE		<font> 0061
1D5EF		<font> 0062
1D5F0		<font> 0063
1D5F1		<font> 0064
1D5F2		<font> 0065
1D5F3		<font> 0066
1D5F4		<font> 0067
1D5F5		<font> 0068
1D5F6		<font> 0069
1D5F7		<font> 006A
1D5F8		<font> 006B
1D5F9		<font> 006C
1D5FA		<font> 006D
1D5FB		<font> 006E
1D5FC		<font> 006F
1D5FD		<font> 0070
1D5FE		<font> 0071
1D5FF		<font> 0072
1D600		<font> 0073
1D601		<font> 0074
1D602		<font> 0075
1D603		<font> 0076
1D604		<font> 0077
1D605		<font> 0078
1D606		<font> 0079
1D607		<font> 007A
1D608		<font> 0041
1D609		<font> 0042
1D60A		<font> 0043
1D60B		<font> 0044
1D60C		<font> 0045
1D60D		<font> 0046
1D60E		<font> 0047
1D60F		<font> 0048
1D610		<font> 0049
1D611		<font> 004A
1D612		<font> 004B
1D613		<font> 004C
1D614		<font> 004D
1D615		<font> 004E
1D616		<font> 004F
1D617		<font> 0050
1D618		<font> 0051
1D619		<font> 0052
1D61A		<font> 0053
1D61B		<font> 0054
1D61C		<font> 0055
1D61D		<font> 0056
1D61E		<font> 0057
1D61F		<font> 0058
1D620		<font> 0059
1D621		<font> 005A
1D622		<font> 0061
1D623		<font> 0062
1D624		<font> 0063
1D625		<font> 0064
1D626		<font> 0065
1D627		<font> 0066
1D628		<font> 0067
1D629		<font> 0068
1D62A		<font> 0069
1D62B		<font> 006A
1D62C		<font> 006B
1D62D		<font> 006C
1D62E		<font> 006D
1D62F		<font> 006E
1D630		<font> 006F
1D631		<font> 0070
1D632		<font> 0071
1D633		<font> 0072
1D634		<font> 0073
1D635		<font> 0074
1D636		<font> 0075
1D637		<font> 0076
1D638		<font> 0077
1D639		<font> 0078
1D63A		<font> 0079
1D63B		<font> 007A
1D63C		<font> 0041
1D63D		<font> 0042
1D63E		<font> 0043
1D63F		<font> 0044
1D640		<font> 0045
1D641		<font> 0046
1D642		<font> 0047
1D643		<font> 0048
1D644		<font> 0049
1D645		<font> 004A
1D646		<font> 004B
1D647		<font> 004C
1D648		<font> 004D
1D649		<font> 004E
1D64A		<font> 004F
1D64B		<font> 0050
1D64C		<font> 0051
1D64D		<font> 0052
1D64E		<font> 0053
1D64F		<font> 0054
1D650		<font> 0055
1D651		<font> 0056
1D652		<font> 0057
1D653		<font> 0058
1D654		<font> 0059
1D655		<font> 005A
1D656		<font> 0061
1D657		<font> 0062
1D658		<font> 0063
1D659		<font> 0064
1D65A		<font> 0065
1D65B		<font> 0066
1D65C		<font> 0067
1D65D		<font> 0068
1D65E		<font> 0069
1D65F		<font> 006A
1D660		<font> 006B
1D661		<font> 006C
1D662		<font> 006D
1D663		<font> 006E
1D664		<font> 006F
1D665		<font> 0070
1D666		<font> 0071
1D667		<font> 0072
1D668		<font> 0073
1D669		<font> 0074
1D66A		<font> 0075
1D66B		<font> 0076
1D66C		<font> 0077
1D66D		<font> 0078
1D66E		<font> 0079
1D66F		<font> 007A
1D670		<font> 0041
1D671		<font> 0042
1D672		<font> 0043
1D673		<font> 0044
1D674		<font> 0045
1D675		<font> 0046
1D676		<font> 0047
1D677		<font> 0048
1D678		<font> 0049
1D679		<font> 004A
1D67A		<font> 004B
1D67B		<font> 004C
1D67C		<font> 004D
1D67D		<font> 004E
1D67E		<font> 004F
1D67F		<font> 0050
1D680		<font> 0051
1D681		<font> 0052
1D682		<font> 0053
1D683		<font> 0054
1D684		<font> 0055
1D685		<font> 0056
1D686		<font> 0057
1D687		<font> 0058
1D688		<font> 0059
1D689		<font> 005A
1D68A		<font> 0061
1D68B		<font> 0062
1D68C		<font> 0063
1D68D		<font> 0064
1D68E		<font> 0065
1D68F		<font> 0066
1D690		<font> 0067
1D691		<font> 0068
1D692		<font> 0069
1D693		<font> 006A
1D694		<font> 006B
1D695		<font> 006C
1D696		<font> 006D
1D697		<font> 006E
1D698		<font> 006F
1D699		<font> 0070
1D69A		<font> 0071
1D69B		<font> 0072
1D69C		<font> 0073
1D69D		<font> 0074
1D69E		<font> 0075
1D69F		<font> 0076
1D6A0		<font> 0077
1D6A1		<font> 0078
1D6A2		<font> 0079
1D6A3		<font> 007A
1D6A4		<font> 0131
1D6A5		<font> 0237
1D6A8		<font> 0391
1D6A9		<font> 0392
1D6AA		<font> 0393
1D6AB		<font> 0394
1D6AC		<font> 0395
1D6AD		<font> 0396
1D6AE		<font> 0397
1D6AF		<font> 0398
1D6B0		<font> 0399
1D6B1		<font> 039A
1D6B2		<font> 039B
1D6B3		<font> 039C
1D6B4		<font> 039D
1D6B5		<font> 039E
1D6B6		<font> 039F
1D6B7		<font> 03A0
1D6B8		<font> 03A1
1D6B9		<font> 03F4
1D6BA		<font> 03A3
1D6BB		<font> 03A4
1D6BC		<font> 03A5
1D6BD		<font> 03A6
1D6BE		<font> 03A7
1D6BF		<font> 03A8
1D6C0		<font> 03A9
1D6C1		<font> 2207
1D6C2		<font> 03B1
1D6C3		<font> 03B2
1D6C4		<font> 03B3
1D6C5		<font> 03B4
1D6C6		<font> 03B5
1D6C7		<font> 03B6
1D6C8		<font> 03B7
1D6C9		<font> 03B8
1D6CA		<font> 03B9
1D6CB		<font> 03BA
1D6CC		<font> 03BB
1D6CD		<font> 03BC
1D6CE		<font> 03BD
1D6CF		<font> 03BE
1D6D0		<font> 03BF
1D6D1		<font> 03C0
1D6D2		<font> 03C1
1D6D3		<font> 03C2
1D6D4		<font> 03C3
1D6D5		<font> 03C4
1D6D6		<font> 03C5
1D6D7		<font> 03C6
1D6D8		<font> 03C7
1D6D9		<font> 03C8
1D6DA		<font> 03C9
1D6DB		<font> 2202
1D6DC		<font> 03F5
1D6DD		<font> 03D1
1D6DE		<font> 03F0
1D6DF		<font> 03D5
1D6E0		<font> 03F1
1D6E1		<font> 03D6
1D6E2		<font> 0391
1D6E3		<font> 0392
1D6E4		<font> 0393
1D6E5		<font> 0394
1D6E6		<font> 0395
1D6E7		<font> 0396
1D6E8		<font> 0397
1D6E9		<font> 0398
1D6EA		<font> 0399
1D6EB		<font> 039A
1D6EC		<font> 039B
1D6ED		<font> 039C
1D6EE		<font> 039D
1D6EF		<font> 039E
1D6F0		<font> 039F
1D6F1		<font> 03A0
1D6F2		<font> 03A1
1D6F3		<font> 03F4
1D6F4		<font> 03A3
1D6F5		<font> 03A4
1D6F6		<font> 03A5
1D6F7		<font> 03A6
1D6F8		<font> 03A7
1D6F9		<font> 03A8
1D6FA		<font> 03A9
1D6FB		<font> 2207
1D6FC		<font> 03B1
1D6FD		<font> 03B2
1D6FE		<font> 03B3
1D6FF		<font> 03B4
1D700		<font> 03B5
1D701		<font> 03B6
1D702		<font> 03B7
1D703		<font> 03B8
1D704		<font> 03B9
1D705		<font> 03BA
1D706		<font> 03BB
1D707		<font> 03BC
1D708		<font> 03BD
1D709		<font> 03BE
1D70A		<font> 03BF
1D70B		<font> 03C0
1D70C		<font> 03C1
1D70D		<font> 03C2
1D70E		<font> 03C3
1D70F		<font> 03C4
1D710		<font> 03C5
1D711		<font> 03C6
1D712		<font> 03C7
1D713		<font> 03C8
1D714		<font> 03C9
1D715		<font> 2202
1D716		<font> 03F5
1D717		<font> 03D1
1D718		<font> 03F0
1D719		<font> 03D5
1D71A		<font> 03F1
1D71B		<font> 03D6
1D71C		<font> 0391
1D71D		<font> 0392
1D71E		<font> 0393
1D71F		<font> 0394
1D720		<font> 0395
1D721		<font> 0396
1D722		<font> 0397
1D723		<font> 0398
1D724		<font> 0399
1D725		<font> 039A
1D726		<font> 039B
1D727		<font> 039C
1D728		<font> 039D
1D729		<font> 039E
1D72A		<font> 039F
1D72B		<font> 03A0
1D72C		<font> 03A1
1D72D		<font> 03F4
1D72E		<font> 03A3
1D72F		<font> 03A4
1D730		<font> 03A5
1D731		<font> 03A6
1D732		<font> 03A7
1D733		<font> 03A8
1D734		<font> 03A9
1D735		<font> 2207
1D736		<font> 03B1
1D737		<font> 03B2
1D738		<font> 03B3
1D739		<font> 03B4
1D73A		<font> 03B5
1D73B		<font> 03B6
1D73C		<font> 03B7
1D73D		<font> 03B8
1D73E		<font> 03B9
1D73F		<font> 03BA
1D740		<font> 03BB
1D741		<font> 03BC
1D742		<font> 03BD
1D743		<font> 03BE
1D744		<font> 03BF
1D745		<font> 03C0
1D746		<font> 03C1
1D747		<font> 03C2
1D748		<font> 03C3
1D749		<font> 03C4
1D74A		<font> 03C5
1D74B		<font> 03C6
1D74C		<font> 03C7
1D74D		<font> 03C8
1D74E		<font> 03C9
1D74F		<font> 2202
1D750		<font> 03F5
1D751		<font> 03D1
1D752		<font> 03F0
1D753		<font> 03D5
1D754		<font> 03F1
1D755		<font> 03D6
1D756		<font> 0391
1D757		<font> 0392
1D758		<font> 0393
1D759		<font> 0394
1D75A		<font> 0395
1D75B		<font> 0396
1D75C		<font> 0397
1D75D		<font> 0398
1D75E		<font> 0399
1D75F		<font> 039A
1D760		<font> 039B
1D761		<font> 039C
1D762		<font> 039D
1D763		<font> 039E
1D764		<font> 039F
1D765		<font> 03A0
1D766		<font> 03A1
1D767		<font> 03F4
1D768		<font> 03A3
1D769		<font> 03A4
1D76A		<font> 03A5
1D76B		<font> 03A6
1D76C		<font> 03A7
1D76D		<font> 03A8
1D76E		<font> 03A9
1D76F		<font> 2207
1D770		<font> 03B1
1D771		<font> 03B2
1D772		<font> 03B3
1D773		<font> 03B4
1D774		<font> 03B5
1D775		<font> 03B6
1D776		<font> 03B7
1D777		<font> 03B8
1D778		<font> 03B9
1D779		<font> 03BA
1D77A		<font> 03BB
1D77B		<font> 03BC
1D77C		<font> 03BD
1D77D		<font> 03BE
1D77E		<font> 03BF
1D77F		<font> 03C0
1D780		<font> 03C1
1D781		<font> 03C2
1D782		<font> 03C3
1D783		<font> 03C4
1D784		<font> 03C5
1D785		<font> 03C6
1D786		<font> 03C7
1D787		<font> 03C8
1D788		<font> 03C9
1D789		<font> 2202
1D78A		<font> 03F5
1D78B		<font> 03D1
1D78C		<font> 03F0
1D78D		<font> 03D5
1D78E		<font> 03F1
1D78F		<font> 03D6
1D790		<font> 0391
1D791		<font> 0392
1D792		<font> 0393
1D793		<font> 0394
1D794		<font> 0395
1D795		<font> 0396
1D796		<font> 0397
1D797		<font> 0398
1D798		<font> 0399
1D799		<font> 039A
1D79A		<font> 039B
1D79B		<font> 039C
1D79C		<font> 039D
1D79D		<font> 039E
1D79E		<font> 039F
1D79F		<font> 03A0
1D7A0		<font> 03A1
1D7A1		<font> 03F4
1D7A2		<font> 03A3
1D7A3		<font> 03A4
1D7A4		<font> 03A5
1D7A5		<font> 03A6
1D7A6		<font> 03A7
1D7A7		<font> 03A8
1D7A8		<font> 03A9
1D7A9		<font> 2207
1D7AA		<font> 03B1
1D7AB		<font> 03B2
1D7AC		<font> 03B3
1D7AD		<font> 03B4
1D7AE		<font> 03B5
1D7AF		<font> 03B6
1D7B0		<font> 03B7
1D7B1		<font> 03B8
1D7B2		<font> 03B9
1D7B3		<font> 03BA
1D7B4		<font> 03BB
1D7B5		<font> 03BC
1D7B6		<font> 03BD
1D7B7		<font> 03BE
1D7B8		<font> 03BF
1D7B9		<font> 03C0
1D7BA		<font> 03C1
1D7BB		<font> 03C2
1D7BC		<font> 03C3
1D7BD		<font> 03C4
1D7BE		<font> 03C5
1D7BF		<font> 03C6
1D7C0		<font> 03C7
1D7C1		<font> 03C8
1D7C2		<font> 03C9
1D7C3		<font> 2202
1D7C4		<font> 03F5
1D7C5		<font> 03D1
1D7C6		<font> 03F0
1D7C7		<font> 03D5
1D7C8		<font> 03F1
1D7C9		<font> 03D6
1D7CA		<font> 03DC
1D7CB		<font> 03DD
1D7CE		<font> 0030
1D7CF		<font> 0031
1D7D0		<font> 0032
1D7D1		<font> 0033
1D7D2		<font> 0034
1D7D3		<font> 0035
1D7D4		<font> 0036
1D7D5		<font> 0037
1D7D6		<font> 0038
1D7D7		<font> 0039
1D7D8		<font> 0030
1D7D9		<font> 0031
1D7DA		<font> 0032
1D7DB		<font> 0033
1D7DC		<font> 0034
1D7DD		<font> 0035
1D7DE		<font> 0036
1D7DF		<font> 0037
1D7E0		<font> 0038
1D7E1		<font> 0039
1D7E2		<font> 0030
1D7E3		<font> 0031
1D7E4		<font> 0032
1D7E5		<font> 0033
1D7E6		<font> 0034
1D7E7		<font> 0035
1D7E8		<font> 0036
1D7E9		<font> 0037
1D7EA		<font> 0038
1D7EB		<font> 0039
1D7EC		<font> 0030
1D7ED		<font> 0031
1D7EE		<font> 0032
1D7EF		<font> 0033
1D7F0		<font> 0034
1D7F1		<font> 0035
1D7F2		<font> 0036
1D7F3		<font> 0037
1D7F4		<font> 0038
1D7F5		<font> 0039
1D7F6		<font> 0030
1D7F7		<font> 0031
1D7F8		<font> 0032
1D7F9		<font> 0033
1D7FA		<font> 0034
1D7FB		<font> 0035
1D7FC		<font> 0036
1D7FD		<font> 0037
1D7FE		<font> 0038
1D7FF		<font> 0039
1EE00		<font> 0627
1EE01		<font> 0628
1EE02		<font> 062C
1EE03		<font> 062F
1EE05		<font> 0648
1EE06		<font> 0632
1EE07		<font> 062D
1EE08		<font> 0637
1EE09		<font> 064A
1EE0A		<font> 0643
1EE0B		<font> 0644
1EE0C		<font> 0645
1EE0D		<font> 0646
1EE0E		<font> 0633
1EE0F		<font> 0639
1EE10		<font> 0641
1EE11		<font> 0635
1EE12		<font> 0642
1EE13		<font> 0631
1EE14		<font> 0634
1EE15		<font> 062A
1EE16		<font> 062B
1EE17		<font> 062E
1EE18		<font> 0630
1EE19		<font> 0636
1EE1A		<font> 0638
1EE1B		<font> 063A
1EE1C		<font> 066E
1EE1D		<font> 06BA
1EE1E		<font> 06A1
1EE1F		<font> 066F
1EE21		<font> 0628
1EE22		<font> 062C
1EE24		<font> 0647
1EE27		<font> 062D
1EE29		<font> 064A
1EE2A		<font> 0643
1EE2B		<font> 0644
1EE2C		<font> 0645
1EE2D		<font> 0646
1EE2E		<font> 0633
1EE2F		<font> 0639
1EE30		<font> 0641
1EE31		<font> 0635
1EE32		<font> 0642
1EE34		<font> 0634
1EE35		<font> 062A
1EE36		<font> 062B
1EE37		<font> 062E
1EE39		<font> 0636
1EE3B		<font> 063A
1EE42		<font> 062C
1EE47		<font> 062D
1EE49		<font> 064A
1EE4B		<font> 0644
1EE4D		<font> 0646
1EE4E		<font> 0633
1EE4F		<font> 0639
1EE51		<font> 0635
1EE52		<font> 0642
1EE54		<font> 0634
1EE57		<font> 062E
1EE59		<font> 0636
1EE5B		<font> 063A
1EE5D		<font> 06BA
1EE5F		<font> 066F
1EE61		<font> 0628
1EE62		<font> 062C
1EE64		<font> 0647
1EE67		<font> 062D
1EE68		<font> 0637
1EE69		<font> 064A
1EE6A		<font> 0643
1EE6C		<font> 0645
1EE6D		<font> 0646
1EE6E		<font> 0633
1EE6F		<font> 0639
1EE70		<font> 0641
1EE71		<font> 0635
1EE72		<font> 0642
1EE74		<font> 0634
1EE75		<font> 062A
1EE76		<font> 062B
1EE77		<font> 062E
1EE79		<font> 0636
1EE7A		<font> 0638
1EE7B		<font> 063A
1EE7C		<font> 066E
1EE7E		<font> 06A1
1EE80		<font> 0627
1EE81		<font> 0628
1EE82		<font> 062C
1EE83		<font> 062F
1EE84		<font> 0647
1EE85		<font> 0648
1EE86		<font> 0632
1EE87		<font> 062D
1EE88		<font> 0637
1EE89		<font> 064A
1EE8B		<font> 0644
1EE8C		<font> 0645
1EE8D		<font> 0646
1EE8E		<font> 0633
1EE8F		<font> 0639
1EE90		<font> 0641
1EE91		<font> 0635
1EE92		<font> 0642
1EE93		<font> 0631
1EE94		<font> 0634
1EE95		<font> 062A
1EE96		<font> 062B
1EE97		<font> 062E
1EE98		<font> 0630
1EE99		<font> 0636
1EE9A		<font> 0638
1EE9B		<font> 063A
1EEA1		<font> 0628
1EEA2		<font> 062C
1EEA3		<font> 062F
1EEA5		<font> 0648
1EEA6		<font> 0632
1EEA7		<font> 062D
1EEA8		<font> 0637
1EEA9		<font> 064A
1EEAB		<font> 0644
1EEAC		<font> 0645
1EEAD		<font> 0646
1EEAE		<font> 0633
1EEAF		<font> 0639
1EEB0		<font> 0641
1EEB1		<font> 0635
1EEB2		<font> 0642
1EEB3		<font> 0631
1EEB4		<font> 0634
1EEB5		<font> 062A
1EEB6		<font> 062B
1EEB7		<font> 062E
1EEB8		<font> 0630
1EEB9		<font> 0636
1EEBA		<font> 0638
1EEBB		<font> 063A
1F100		<compat> 0030 002E
1F101		<compat> 0030 002C
1F102		<compat> 0031 002C
1F103		<compat> 0032 002C
1F104		<compat> 0033 002C
1F105		<compat> 0034 002C
1F106		<compat> 0035 002C
1F107		<compat> 0036 002C
1F108		<compat> 0037 002C
1F109		<compat> 0038 002C
1F10A		<compat> 0039 002C
1F110		<compat> 0028 0041 0029
1F111		<compat> 0028 0042 0029
1F112		<compat> 0028 0043 0029
1F113		<compat> 0028 0044 0029
1F114		<compat> 0028 0045 0029
1F115		<compat> 0028 0046 0029
1F116		<compat> 0028 0047 0029
1F117		<compat> 0028 0048 0029
1F118		<compat> 0028 0049 0029
1F119		<compat> 0028 004A 0029
1F11A		<compat> 0028 004B 0029
1F11B		<compat> 0028 004C 0029
1F11C		<compat> 0028 004D 0029
1F11D		<compat> 0028 004E 0029
1F11E		<compat> 0028 004F 0029
1F11F		<compat> 0028 0050 0029
1F120		<compat> 0028 0051 0029
1F121		<compat> 0028 0052 0029
1F122		<compat> 0028 0053 0029
1F123		<compat> 0028 0054 0029
1F124		<compat> 0028 0055 0029
1F125		<compat> 0028 0056 0029
1F126		<compat> 0028 0057 0029
1F127		<compat> 0028 0058 0029
1F128		<compat> 0028 0059 0029
1F129		<compat> 0028 005A 0029
1F12A		<compat> 3014 0053 3015
1F12B		<circle> 0043
1F12C		<circle> 0052
1F12D		<circle> 0043 0044
1F12E		<circle> 0057 005A
1F130		<square> 0041
1F131		<square> 0042
1F132		<square> 0043
1F133		<square> 0044
1F134		<square> 0045
1F135		<square> 0046
1F136		<square> 0047
1F137		<square> 0048
1F138		<square> 0049
1F139		<square> 004A
1F13A		<square> 004B
1F13B		<square> 004C
1F13C		<square> 004D
1F13D		<square> 004E
1F13E		<square> 004F
1F13F		<square> 0050
1F140		<square> 0051
1F141		<square> 0052
1F142		<square> 0053
1F143		<square> 0054
1F144		<square> 0055
1F145		<square> 0056
1F146		<square> 0057
1F147		<square> 0058
1F148		<square> 0059
1F149		<square> 005A
1F14A		<square> 0048 0056
1F14B		<square> 004D 0056
1F14C		<square> 0053 0044
1F14D		<square> 0053 0053
1F14E		<square> 0050 0050 0056
1F14F		<square> 0057 0043
1F16A		<super> 004D 0043
1F16B		<super> 004D 0044
1F16C		<super> 004D 0052
1F190		<square> 0044 004A
1F200		<square> 307B 304B
1F201		<square> 30B3 30B3
1F202		<square> 30B5
1F210		<square> 624B
1F211		<square> 5B57
1F212		<square> 53CC
1F213		<square> 30C7
1F214		<square> 4E8C
1F215		<square> 591A
1F216		<square> 89E3
1F217		<square> 5929
1F218		<square> 4EA4
1F219		<square> 6620
1F21A		<square> 7121
1F21B		<square> 6599
1F21C		<square> 524D
1F21D		<square> 5F8C
1F21E		<square> 518D
1F21F		<square> 65B0
1F220		<square> 521D
1F221		<square> 7D42
1F222		<square> 751F
1F223		<square> 8CA9
1F224		<square> 58F0
1F225		<square> 5439
1F226		<square> 6F14
1F227		<square> 6295
1F228		<square> 6355
1F229		<square> 4E00
1F22A		<square> 4E09
1F22B		<square> 904A
1F22C		<square> 5DE6
1F22D		<square> 4E2D
1F22E		<square> 53F3
1F22F		<square> 6307
1F230		<square> 8D70
1F231		<square> 6253
1F232		<square> 7981
1F233		<square> 7A7A
1F234		<square> 5408
1F235		<square> 6E80
1F236		<square> 6709
1F237		<square> 6708
1F238		<square> 7533
1F239		<square> 5272
1F23A		<square> 55B6
1F23B		<square> 914D
1F240		<compat> 3014 672C 3015
1F241		<compat> 3014 4E09 3015
1F242		<compat> 3014 4E8C 3015
1F243		<compat> 3014 5B89 3015
1F244		<compat> 3014 70B9 3015
1F245		<compat> 3014 6253 3015
1F246		<compat> 3014 76D7 3015
1F247		<compat> 3014 52DD 3015
1F248		<compat> 3014 6557 3015
1F250		<circle> 5F97
1F251		<circle> 53EF
1FBF0		<font> 0030
1FBF1		<font> 0031
1FBF2		<font> 0032
1FBF3		<font> 0033
1FBF4		<font> 0034
1FBF5		<font> 0035
1FBF6		<font> 0036
1FBF7		<font> 0037
1FBF8		<font> 0038
1FBF9		<font> 0039
2F800		4E3D
2F801		4E38
2F802		4E41
2F803		20122
2F804		4F60
2F805		4FAE
2F806		4FBB
2F807		5002
2F808		507A
2F809		5099
2F80A		50E7
2F80B		50CF
2F80C		349E
2F80D		2063A
2F80E		514D
2F80F		5154
2F810		5164
2F811		5177
2F812		2051C
2F813		34B9
2F814		5167
2F815		518D
2F816		2054B
2F817		5197
2F818		51A4
2F819		4ECC
2F81A		51AC
2F81B		51B5
2F81C		291DF
2F81D		51F5
2F81E		5203
2F81F		34DF
2F820		523B
2F821		5246
2F822		5272
2F823		5277
2F824		3515
2F825		52C7
2F826		52C9
2F827		52E4
2F828		52FA
2F829		5305
2F82A		5306
2F82B		5317
2F82C		5349
2F82D		5351
2F82E		535A
2F82F		5373
2F830		537D
2F831	2F833	537F
2F834		20A2C
2F835		7070
2F836		53CA
2F837		53DF
2F838		20B63
2F839		53EB
2F83A		53F1
2F83B		5406
2F83C		549E
2F83D		5438
2F83E		5448
2F83F		5468
2F840		54A2
2F841		54F6
2F842		5510
2F843		5553
2F844		5563
2F845	2F846	5584
2F847		5599
2F848		55AB
2F849		55B3
2F84A		55C2
2F84B		5716
2F84C		5606
2F84D		5717
2F84E		5651
2F84F		5674
2F850		5207
2F851		58EE
2F852		57CE
2F853		57F4
2F854		580D
2F855		578B
2F856		5832
2F857		5831
2F858		58AC
2F859		214E4
2F85A		58F2
2F85B		58F7
2F85C		5906
2F85D		591A
2F85E		5922
2F85F		5962
2F860		216A8
2F861		216EA
2F862		59EC
2F863		5A1B
2F864		5A27
2F865		59D8
2F866		5A66
2F867		36EE
2F868		36FC
2F869		5B08
2F86A	2F86B	5B3E
2F86C		219C8
2F86D		5BC3
2F86E		5BD8
2F86F		5BE7
2F870		5BF3
2F871		21B18
2F872		5BFF
2F873		5C06
2F874		5F53
2F875		5C22
2F876		3781
2F877		5C60
2F878		5C6E
2F879		5CC0
2F87A		5C8D
2F87B		21DE4
2F87C		5D43
2F87D		21DE6
2F87E		5D6E
2F87F		5D6B
2F880		5D7C
2F881		5DE1
2F882		5DE2
2F883		382F
2F884		5DFD
2F885		5E28
2F886		5E3D
2F887		5E69
2F888		3862
2F889		22183
2F88A		387C
2F88B		5EB0
2F88C		5EB3
2F88D		5EB6
2F88E		5ECA
2F88F		2A392
2F890		5EFE
2F891	2F892	22331
2F893		8201
2F894	2F895	5F22
2F896		38C7
2F897		232B8
2F898		261DA
2F899		5F62
2F89A		5F6B
2F89B		38E3
2F89C		5F9A
2F89D		5FCD
2F89E		5FD7
2F89F		5FF9
2F8A0		6081
2F8A1		393A
2F8A2		391C
2F8A3		6094
2F8A4		226D4
2F8A5		60C7
2F8A6		6148
2F8A7		614C
2F8A8		614E
2F8A9		614C
2F8AA		617A
2F8AB		618E
2F8AC		61B2
2F8AD		61A4
2F8AE		61AF
2F8AF		61DE
2F8B0		61F2
2F8B1		61F6
2F8B2		6210
2F8B3		621B
2F8B4		625D
2F8B5		62B1
2F8B6		62D4
2F8B7		6350
2F8B8		22B0C
2F8B9		633D
2F8BA		62FC
2F8BB		6368
2F8BC		6383
2F8BD		63E4
2F8BE		22BF1
2F8BF		6422
2F8C0		63C5
2F8C1		63A9
2F8C2		3A2E
2F8C3		6469
2F8C4		647E
2F8C5		649D
2F8C6		6477
2F8C7		3A6C
2F8C8		654F
2F8C9		656C
2F8CA		2300A
2F8CB		65E3
2F8CC		66F8
2F8CD		6649
2F8CE		3B19
2F8CF		6691
2F8D0		3B08
2F8D1		3AE4
2F8D2		5192
2F8D3		5195
2F8D4		6700
2F8D5		669C
2F8D6		80AD
2F8D7		43D9
2F8D8		6717
2F8D9		671B
2F8DA		6721
2F8DB		675E
2F8DC		6753
2F8DD		233C3
2F8DE		3B49
2F8DF		67FA
2F8E0		6785
2F8E1		6852
2F8E2		6885
2F8E3		2346D
2F8E4		688E
2F8E5		681F
2F8E6		6914
2F8E7		3B9D
2F8E8		6942
2F8E9		69A3
2F8EA		69EA
2F8EB		6AA8
2F8EC		236A3
2F8ED		6ADB
2F8EE		3C18
2F8EF		6B21
2F8F0		238A7
2F8F1		6B54
2F8F2		3C4E
2F8F3		6B72
2F8F4		6B9F
2F8F5		6BBA
2F8F6		6BBB
2F8F7		23A8D
2F8F8		21D0B
2F8F9		23AFA
2F8FA		6C4E
2F8FB		23CBC
2F8FC		6CBF
2F8FD		6CCD
2F8FE		6C67
2F8FF		6D16
2F900		6D3E
2F901		6D77
2F902		6D41
2F903		6D69
2F904		6D78
2F905		6D85
2F906		23D1E
2F907		6D34
2F908		6E2F
2F909		6E6E
2F90A		3D33
2F90B		6ECB
2F90C		6EC7
2F90D		23ED1
2F90E		6DF9
2F90F		6F6E
2F910		23F5E
2F911		23F8E
2F912		6FC6
2F913		7039
2F914		701E
2F915		701B
2F916		3D96
2F917		704A
2F918		707D
2F919		7077
2F91A		70AD
2F91B		20525
2F91C		7145
2F91D		24263
2F91E		719C
2F91F		243AB
2F920		7228
2F921		7235
2F922		7250
2F923		24608
2F924		7280
2F925		7295
2F926		24735
2F927		24814
2F928		737A
2F929		738B
2F92A		3EAC
2F92B		73A5
2F92C	2F92D	3EB8
2F92E		7447
2F92F		745C
2F930		7471
2F931		7485
2F932		74CA
2F933		3F1B
2F934		7524
2F935		24C36
2F936		753E
2F937		24C92
2F938		7570
2F939		2219F
2F93A		7610
2F93B		24FA1
2F93C		24FB8
2F93D		25044
2F93E		3FFC
2F93F		4008
2F940		76F4
2F941		250F3
2F942		250F2
2F943		25119
2F944		25133
2F945		771E
2F946	2F947	771F
2F948		774A
2F949		4039
2F94A		778B
2F94B		4046
2F94C		4096
2F94D		2541D
2F94E		784E
2F94F		788C
2F950		78CC
2F951		40E3
2F952		25626
2F953		7956
2F954		2569A
2F955		256C5
2F956		798F
2F957		79EB
2F958		412F
2F959		7A40
2F95A		7A4A
2F95B		7A4F
2F95C		2597C
2F95D	2F95E	25AA7
2F95F		7AEE
2F960		4202
2F961		25BAB
2F962		7BC6
2F963		7BC9
2F964		4227
2F965		25C80
2F966		7CD2
2F967		42A0
2F968		7CE8
2F969		7CE3
2F96A		7D00
2F96B		25F86
2F96C		7D63
2F96D		4301
2F96E		7DC7
2F96F		7E02
2F970		7E45
2F971		4334
2F972		26228
2F973		26247
2F974		4359
2F975		262D9
2F976		7F7A
2F977		2633E
2F978		7F95
2F979		7FFA
2F97A		8005
2F97B		264DA
2F97C		26523
2F97D		8060
2F97E		265A8
2F97F		8070
2F980		2335F
2F981		43D5
2F982		80B2
2F983		8103
2F984		440B
2F985		813E
2F986		5AB5
2F987		267A7
2F988		267B5
2F989		23393
2F98A		2339C
2F98B		8201
2F98C		8204
2F98D		8F9E
2F98E		446B
2F98F		8291
2F990		828B
2F991		829D
2F992		52B3
2F993		82B1
2F994		82B3
2F995		82BD
2F996		82E6
2F997		26B3C
2F998		82E5
2F999		831D
2F99A		8363
2F99B		83AD
2F99C		8323
2F99D		83BD
2F99E		83E7
2F99F		8457
2F9A0		8353
2F9A1		83CA
2F9A2		83CC
2F9A3		83DC
2F9A4		26C36
2F9A5		26D6B
2F9A6		26CD5
2F9A7		452B
2F9A8		84F1
2F9A9		84F3
2F9AA		8516
2F9AB		273CA
2F9AC		8564
2F9AD		26F2C
2F9AE		455D
2F9AF		4561
2F9B0		26FB1
2F9B1		270D2
2F9B2		456B
2F9B3		8650
2F9B4		865C
2F9B5		8667
2F9B6		8669
2F9B7		86A9
2F9B8		8688
2F9B9		870E
2F9BA		86E2
2F9BB		8779
2F9BC		8728
2F9BD		876B
2F9BE		8786
2F9BF		45D7
2F9C0		87E1
2F9C1		8801
2F9C2		45F9
2F9C3		8860
2F9C4		8863
2F9C5		27667
2F9C6		88D7
2F9C7		88DE
2F9C8		4635
2F9C9		88FA
2F9CA		34BB
2F9CB		278AE
2F9CC		27966
2F9CD		46BE
2F9CE		46C7
2F9CF		8AA0
2F9D0		8AED
2F9D1		8B8A
2F9D2		8C55
2F9D3		27CA8
2F9D4		8CAB
2F9D5		8CC1
2F9D6		8D1B
2F9D7		8D77
2F9D8		27F2F
2F9D9		20804
2F9DA		8DCB
2F9DB		8DBC
2F9DC		8DF0
2F9DD		208DE
2F9DE		8ED4
2F9DF		8F38
2F9E0		285D2
2F9E1		285ED
2F9E2		9094
2F9E3		90F1
2F9E4		9111
2F9E5		2872E
2F9E6		911B
2F9E7		9238
2F9E8		92D7
2F9E9		92D8
2F9EA		927C
2F9EB		93F9
2F9EC		9415
2F9ED		28BFA
2F9EE		958B
2F9EF		4995
2F9F0		95B7
2F9F1		28D77
2F9F2		49E6
2F9F3		96C3
2F9F4		5DB2
2F9F5		9723
2F9F6		29145
2F9F7		2921A
2F9F8		4A6E
2F9F9		4A76
2F9FA		97E0
2F9FB		2940A
2F9FC		4AB2
2F9FD		29496
2F9FE	2F9FF	980B
2FA00		9829
2FA01		295B6
2FA02		98E2
2FA03		4B33
2FA04		9929
2FA05		99A7
2FA06		99C2
2FA07		99FE
2FA08		4BCE
2FA09		29B30
2FA0A		9B12
2FA0B		9C40
2FA0C		9CFD
2FA0D		4CCE
2FA0E		4CED
2FA0F		9D67
2FA10		2A0CE
2FA11		4CF8
2FA12		2A105
2FA13		2A20E
2FA14		2A291
2FA15		9EBB
2FA16		4D56
2FA17		9EF9
2FA18		9EFE
2FA19		9F05
2FA1A		9F0F
2FA1B		9F16
2FA1C		9F3B
2FA1D		2A600
END
              .    4 ..                                           nbdkit_full_plugin_la-full.Plo                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2e|,  .   p,  ..  ,  
.npmignore  rb  License b  Makefileb  equation.giff  testWg  example k  index.jso  lib *s  package.jsont  	README.md   { 4.travis.yml                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       A
b,  .   p,  ..  ,  crc32   ,  crc32c  ,  ie11-detection  ,  sha1-browser,  sha256-browser  ,  	sha256-js   ,  supports-web-crypto , Hutil                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  vY v,  .   ,  ..  ,  LICENSE b  node_modulese  build   Nr  package.jsonRs  
tsconfig.json   s  CHANGELOG.mds  	README.md   u Tsrc                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               GLB,  .   ,  ..  ,  LICENSE b  node_modulese  build   Rr  package.jsonSs  
tsconfig.json   s  CHANGELOG.mds  	README.md   u Tsrc                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ޽+package ExtUtils::MM_Unix;

require 5.006;

use strict;
use warnings;

use Carp;
use ExtUtils::MakeMaker::Config;
use File::Basename qw(basename dirname);

our %Config_Override;

use ExtUtils::MakeMaker qw($Verbose neatvalue _sprintf562);

# If we make $VERSION an our variable parse_version() breaks
use vars qw($VERSION);
$VERSION = '7.64';
$VERSION =~ tr/_//d;

require ExtUtils::MM_Any;
our @ISA = qw(ExtUtils::MM_Any);

my %Is;
BEGIN {
    $Is{OS2}     = $^O eq 'os2';
    $Is{Win32}   = $^O eq 'MSWin32' || $Config{osname} eq 'NetWare';
    $Is{Dos}     = $^O eq 'dos';
    $Is{VMS}     = $^O eq 'VMS';
    $Is{OSF}     = $^O eq 'dec_osf';
    $Is{IRIX}    = $^O eq 'irix';
    $Is{NetBSD}  = $^O eq 'netbsd';
    $Is{Interix} = $^O eq 'interix';
    $Is{SunOS4}  = $^O eq 'sunos';
    $Is{Solaris} = $^O eq 'solaris';
    $Is{SunOS}   = $Is{SunOS4} || $Is{Solaris};
    $Is{BSD}     = ($^O =~ /^(?:free|net|open)bsd$/ or
                   grep( $^O eq $_, qw(bsdos interix dragonfly) )
                  );
    $Is{Android} = $^O =~ /android/;
    if ( $^O eq 'darwin' && $^X eq '/usr/bin/perl' ) {
      my @osvers = split /\./, $Config{osvers};
      $Is{ApplCor} = ( $osvers[0] >= 18 );
    }
}

BEGIN {
    if( $Is{VMS} ) {
        # For things like vmsify()
        require VMS::Filespec;
        VMS::Filespec->import;
    }
}


=head1 NAME

ExtUtils::MM_Unix - methods used by ExtUtils::MakeMaker

=head1 SYNOPSIS

  require ExtUtils::MM_Unix;

=head1 DESCRIPTION

The methods provided by this package are designed to be used in
conjunction with L<ExtUtils::MakeMaker>. When MakeMaker writes a
Makefile, it creates one or more objects that inherit their methods
from a package L<MM|ExtUtils::MM>. MM itself doesn't provide any methods, but
it ISA ExtUtils::MM_Unix class. The inheritance tree of MM lets operating
specific packages take the responsibility for all the methods provided
by MM_Unix. We are trying to reduce the number of the necessary
overrides by defining rather primitive operations within
ExtUtils::MM_Unix.

If you are going to write a platform specific MM package, please try
to limit the necessary overrides to primitive methods, and if it is not
possible to do so, let's work out how to achieve that gain.

If you are overriding any of these methods in your Makefile.PL (in the
MY class), please report that to the makemaker mailing list. We are
trying to minimize the necessary method overrides and switch to data
driven Makefile.PLs wherever possible. In the long run less methods
will be overridable via the MY class.

=head1 METHODS

The following description of methods is still under
development. Please refer to the code for not suitably documented
sections and complain loudly to the makemaker@perl.org mailing list.
Better yet, provide a patch.

Not all of the methods below are overridable in a
Makefile.PL. Overridable methods are marked as (o). All methods are
overridable by a platform specific MM_*.pm file.

Cross-platform methods are being moved into L<MM_Any|ExtUtils::MM_Any>.
If you can't find something that used to be in here, look in MM_Any.

=cut

# So we don't have to keep calling the methods over and over again,
# we have these globals to cache the values.  Faster and shrtr.
my $Curdir  = __PACKAGE__->curdir;
my $Updir   = __PACKAGE__->updir;


=head2 Methods

=over 4

=item os_flavor

Simply says that we're Unix.

=cut

sub os_flavor {
    return('Unix');
}


=item c_o (o)

Defines the suffix rules to compile different flavors of C files to
object files.

=cut

sub c_o {
# --- Translation Sections ---

    my($self) = shift;
    return '' unless $self->needs_linking();
    my(@m);

    my $command = '$(CCCMD)';
    my $flags   = '$(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE)';

    if ( $Is{ApplCor} ) {
        $flags =~ s/"-I(\$\(PERL_INC\))"/-iwithsysroot "$1"/;
    }

    if (my $cpp = $self->{CPPRUN}) {
        my $cpp_cmd = $self->const_cccmd;
        $cpp_cmd =~ s/^CCCMD\s*=\s*\$\(CC\)/\$(CPPRUN)/;
        push @m, qq{
.c.i:
	$cpp_cmd $flags \$*.c > \$*.i
};
    }

    my $m_o = $self->{XSMULTI} ? $self->xs_obj_opt('$*.s') : '';
    push @m, sprintf <<'EOF', $command, $flags, $m_o;

.c.s :
	%s -S %s $*.c %s
EOF

    my @exts = qw(c cpp cxx cc);
    push @exts, 'C' if !$Is{OS2} and !$Is{Win32} and !$Is{Dos}; #Case-specific
    $m_o = $self->{XSMULTI} ? $self->xs_obj_opt('$*$(OBJ_EXT)') : '';
    my $dbgout = $self->dbgoutflag;
    for my $ext (@exts) {
	push @m, "\n.$ext\$(OBJ_EXT) :\n\t$command $flags "
            .($dbgout?"$dbgout ":'')
            ."\$*.$ext" . ( $m_o ? " $m_o" : '' ) . "\n";
    }
    return join "", @m;
}


=item xs_obj_opt

Takes the object file as an argument, and returns the portion of compile
command-line that will output to the specified object file.

=cut

sub xs_obj_opt {
    my ($self, $output_file) = @_;
    "-o $output_file";
}

=item dbgoutflag

Returns a CC flag that tells the CC to emit a separate debugging symbol file
when compiling an object file.

=cut

sub dbgoutflag {
    '';
}

=item cflags (o)

Does very much the same as the cflags script in the perl
distribution. It doesn't return the whole compiler command line, but
initializes all of its parts. The const_cccmd method then actually
returns the definition of the CCCMD macro which uses these parts.

=cut

#'

sub cflags {
    my($self,$libperl)=@_;
    return $self->{CFLAGS} if $self->{CFLAGS};
    return '' unless $self->needs_linking();

    my($prog, $uc, $perltype, %cflags);
    $libperl ||= $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
    $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;

    @cflags{qw(cc ccflags optimize shellflags)}
	= @Config{qw(cc ccflags optimize shellflags)};

    # Perl 5.21.4 adds the (gcc) warning (-Wall ...) and std (-std=c89)
    # flags to the %Config, and the modules in the core should be built
    # with the warning flags, but NOT the -std=c89 flags (the latter
    # would break using any system header files that are strict C99).
    my @ccextraflags = qw(ccwarnflags);
    if ($ENV{PERL_CORE}) {
      for my $x (@ccextraflags) {
        if (exists $Config{$x}) {
          $cflags{$x} = $Config{$x};
        }
      }
    }

    my($optdebug) = "";

    $cflags{shellflags} ||= '';

    my(%map) =  (
		D =>   '-DDEBUGGING',
		E =>   '-DEMBED',
		DE =>  '-DDEBUGGING -DEMBED',
		M =>   '-DEMBED -DMULTIPLICITY',
		DM =>  '-DDEBUGGING -DEMBED -DMULTIPLICITY',
		);

    if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
	$uc = uc($1);
    } else {
	$uc = ""; # avoid warning
    }
    $perltype = $map{$uc} ? $map{$uc} : "";

    if ($uc =~ /^D/) {
	$optdebug = "-g";
    }


    my($name);
    ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
    if ($prog = $Config{$name}) {
	# Expand hints for this extension via the shell
	print "Processing $name hint:\n" if $Verbose;
	my(@o)=`cc=\"$cflags{cc}\"
	  ccflags=\"$cflags{ccflags}\"
	  optimize=\"$cflags{optimize}\"
	  perltype=\"$cflags{perltype}\"
	  optdebug=\"$cflags{optdebug}\"
	  eval '$prog'
	  echo cc=\$cc
	  echo ccflags=\$ccflags
	  echo optimize=\$optimize
	  echo perltype=\$perltype
	  echo optdebug=\$optdebug
	  `;
	foreach my $line (@o){
	    chomp $line;
	    if ($line =~ /(.*?)=\s*(.*)\s*$/){
		$cflags{$1} = $2;
		print "	$1 = $2\n" if $Verbose;
	    } else {
		print "Unrecognised result from hint: '$line'\n";
	    }
	}
    }

    if ($optdebug) {
	$cflags{optimize} = $optdebug;
    }

    for (qw(ccflags optimize perltype)) {
        $cflags{$_} ||= '';
	$cflags{$_} =~ s/^\s+//;
	$cflags{$_} =~ s/\s+/ /g;
	$cflags{$_} =~ s/\s+$//;
	$self->{uc $_} ||= $cflags{$_};
    }

    if ($self->{POLLUTE}) {
	$self->{CCFLAGS} .= ' -DPERL_POLLUTE ';
    }

    for my $x (@ccextraflags) {
      next unless exists $cflags{$x};
      $self->{CCFLAGS} .= $cflags{$x} =~ m!^\s! ? $cflags{$x} : ' ' . $cflags{$x};
    }

    my $pollute = '';
    if ($Config{usemymalloc} and not $Config{bincompat5005}
	and not $Config{ccflags} =~ /-DPERL_POLLUTE_MALLOC\b/
	and $self->{PERL_MALLOC_OK}) {
	$pollute = '$(PERL_MALLOC_DEF)';
    }

    return $self->{CFLAGS} = qq{
CCFLAGS = $self->{CCFLAGS}
OPTIMIZE = $self->{OPTIMIZE}
PERLTYPE = $self->{PERLTYPE}
MPOLLUTE = $pollute
};

}


=item const_cccmd (o)

Returns the full compiler call for C programs and stores the
definition in CONST_CCCMD.

=cut

sub const_cccmd {
    my($self,$libperl)=@_;
    return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
    return '' unless $self->needs_linking();
    return $self->{CONST_CCCMD} =
	q{CCCMD = $(CC) -c $(PASTHRU_INC) $(INC) \\
	$(CCFLAGS) $(OPTIMIZE) \\
	$(PERLTYPE) $(MPOLLUTE) $(DEFINE_VERSION) \\
	$(XS_DEFINE_VERSION)};
}

=item const_config (o)

Sets SHELL if needed, then defines a couple of constants in the Makefile
that are imported from %Config.

=cut

sub const_config {
# --- Constants Sections ---

    my($self) = shift;
    my @m = $self->specify_shell(); # Usually returns empty string
    push @m, <<"END";

# These definitions are from config.sh (via $INC{'Config.pm'}).
# They may have been overridden via Makefile.PL or on the command line.
END

    my(%once_only);
    foreach my $key (@{$self->{CONFIG}}){
        # SITE*EXP macros are defined in &constants; avoid duplicates here
        next if $once_only{$key};
        push @m, uc($key) , ' = ' , $self->{uc $key}, "\n";
        $once_only{$key} = 1;
    }
    join('', @m);
}

=item const_loadlibs (o)

Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
L<ExtUtils::Liblist> for details.

=cut

sub const_loadlibs {
    my($self) = shift;
    return "" unless $self->needs_linking;
    my @m;
    push @m, qq{
# $self->{NAME} might depend on some other libraries:
# See ExtUtils::Liblist for details
#
};
    for my $tmp (qw/
         EXTRALIBS LDLOADLIBS BSLOADLIBS
         /) {
        next unless defined $self->{$tmp};
        push @m, "$tmp = $self->{$tmp}\n";
    }
    # don't set LD_RUN_PATH if empty
    for my $tmp (qw/
         LD_RUN_PATH
         /) {
        next unless $self->{$tmp};
        push @m, "$tmp = $self->{$tmp}\n";
    }
    return join "", @m;
}

=item constants (o)

  my $make_frag = $mm->constants;

Prints out macros for lots of constants.

=cut

sub constants {
    my($self) = @_;
    my @m = ();

    $self->{DFSEP} = '$(DIRFILESEP)';  # alias for internal use

    for my $macro (qw(

              AR_STATIC_ARGS DIRFILESEP DFSEP
              NAME NAME_SYM
              VERSION    VERSION_MACRO    VERSION_SYM DEFINE_VERSION
              XS_VERSION XS_VERSION_MACRO             XS_DEFINE_VERSION
              INST_ARCHLIB INST_SCRIPT INST_BIN INST_LIB
              INST_MAN1DIR INST_MAN3DIR
              MAN1EXT      MAN3EXT
              MAN1SECTION  MAN3SECTION
              INSTALLDIRS INSTALL_BASE DESTDIR PREFIX
              PERLPREFIX      SITEPREFIX      VENDORPREFIX
                   ),
                   (map { ("INSTALL".$_,
                          "DESTINSTALL".$_)
                        } $self->installvars),
                   qw(
              PERL_LIB
              PERL_ARCHLIB PERL_ARCHLIBDEP
              LIBPERL_A MYEXTLIB
              FIRST_MAKEFILE MAKEFILE_OLD MAKE_APERL_FILE
              PERLMAINCC PERL_SRC PERL_INC PERL_INCDEP
              PERL            FULLPERL          ABSPERL
              PERLRUN         FULLPERLRUN       ABSPERLRUN
              PERLRUNINST     FULLPERLRUNINST   ABSPERLRUNINST
              PERL_CORE
              PERM_DIR PERM_RW PERM_RWX

	      ) )
    {
	next unless defined $self->{$macro};

        # pathnames can have sharp signs in them; escape them so
        # make doesn't think it is a comment-start character.
        $self->{$macro} =~ s/#/\\#/g;
	$self->{$macro} = $self->quote_dep($self->{$macro})
	  if $ExtUtils::MakeMaker::macro_dep{$macro};
	push @m, "$macro = $self->{$macro}\n";
    }

    push @m, qq{
MAKEMAKER   = $self->{MAKEMAKER}
MM_VERSION  = $self->{MM_VERSION}
MM_REVISION = $self->{MM_REVISION}
};

    push @m, q{
# FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
# BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
# PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
# DLBASE  = Basename part of dynamic library. May be just equal BASEEXT.
};

    for my $macro (qw/
              MAKE
	      FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
	      LDFROM LINKTYPE BOOTDEP
	      /	)
    {
	next unless defined $self->{$macro};
	push @m, "$macro = $self->{$macro}\n";
    }

    push @m, "
# Handy lists of source code files:
XS_FILES = ".$self->wraplist(sort keys %{$self->{XS}})."
C_FILES  = ".$self->wraplist(sort @{$self->{C}})."
O_FILES  = ".$self->wraplist(sort @{$self->{O_FILES}})."
H_FILES  = ".$self->wraplist(sort @{$self->{H}})."
MAN1PODS = ".$self->wraplist(sort keys %{$self->{MAN1PODS}})."
MAN3PODS = ".$self->wraplist(sort keys %{$self->{MAN3PODS}})."
";

    push @m, q{
SDKROOT := $(shell xcrun --show-sdk-path)
PERL_SYSROOT = $(SDKROOT)
} if $Is{ApplCor} && $self->{'PERL_INC'} =~ m!^/System/Library/Perl/!;

    push @m, q{
# Where is the Config information that we are using/depend on
CONFIGDEP = $(PERL_ARCHLIBDEP)$(DFSEP)Config.pm $(PERL_SYSROOT)$(PERL_INCDEP)$(DFSEP)config.h
} if $Is{ApplCor};

    push @m, q{
# Where is the Config information that we are using/depend on
CONFIGDEP = $(PERL_ARCHLIBDEP)$(DFSEP)Config.pm $(PERL_INCDEP)$(DFSEP)config.h
} if -e $self->catfile( $self->{PERL_INC}, 'config.h' ) && !$Is{ApplCor};

    push @m, qq{
# Where to build things
INST_LIBDIR      = $self->{INST_LIBDIR}
INST_ARCHLIBDIR  = $self->{INST_ARCHLIBDIR}

INST_AUTODIR     = $self->{INST_AUTODIR}
INST_ARCHAUTODIR = $self->{INST_ARCHAUTODIR}

INST_STATIC      = $self->{INST_STATIC}
INST_DYNAMIC     = $self->{INST_DYNAMIC}
INST_BOOT        = $self->{INST_BOOT}
};

    push @m, qq{
# Extra linker info
EXPORT_LIST        = $self->{EXPORT_LIST}
PERL_ARCHIVE       = $self->{PERL_ARCHIVE}
PERL_ARCHIVEDEP    = $self->{PERL_ARCHIVEDEP}
PERL_ARCHIVE_AFTER = $self->{PERL_ARCHIVE_AFTER}
};

    push @m, "

TO_INST_PM = ".$self->wraplist(map $self->quote_dep($_), sort keys %{$self->{PM}})."\n";

    join('',@m);
}


=item depend (o)

Same as macro for the depend attribute.

=cut

sub depend {
    my($self,%attribs) = @_;
    my(@m,$key,$val);
    for my $key (sort keys %attribs){
	my $val = $attribs{$key};
	next unless defined $key and defined $val;
	push @m, "$key : $val\n";
    }
    join "", @m;
}


=item init_DEST

  $mm->init_DEST

Defines the DESTDIR and DEST* variables paralleling the INSTALL*.

=cut

sub init_DEST {
    my $self = shift;

    # Initialize DESTDIR
    $self->{DESTDIR} ||= '';

    # Make DEST variables.
    foreach my $var ($self->installvars) {
        my $destvar = 'DESTINSTALL'.$var;
        $self->{$destvar} ||= '$(DESTDIR)$(INSTALL'.$var.')';
    }
}


=item init_dist

  $mm->init_dist;

Defines a lot of macros for distribution support.

  macro         description                     default

  TAR           tar command to use              tar
  TARFLAGS      flags to pass to TAR            cvf

  ZIP           zip command to use              zip
  ZIPFLAGS      flags to pass to ZIP            -r

  COMPRESS      compression command to          gzip --best
                use for tarfiles
  SUFFIX        suffix to put on                .gz
                compressed files

  SHAR          shar command to use             shar

  PREOP         extra commands to run before
                making the archive
  POSTOP        extra commands to run after
                making the archive

  TO_UNIX       a command to convert linefeeds
                to Unix style in your archive

  CI            command to checkin your         ci -u
                sources to version control
  RCS_LABEL     command to label your sources   rcs -Nv$(VERSION_SYM): -q
                just after CI is run

  DIST_CP       $how argument to manicopy()     best
                when the distdir is created

  DIST_DEFAULT  default target to use to        tardist
                create a distribution

  DISTVNAME     name of the resulting archive   $(DISTNAME)-$(VERSION)
                (minus suffixes)

=cut

sub init_dist {
    my $self = shift;

    $self->{TAR}      ||= 'tar';
    $self->{TARFLAGS} ||= 'cvf';
    $self->{ZIP}      ||= 'zip';
    $self->{ZIPFLAGS} ||= '-r';
    $self->{COMPRESS} ||= 'gzip --best';
    $self->{SUFFIX}   ||= '.gz';
    $self->{SHAR}     ||= 'shar';
    $self->{PREOP}    ||= '$(NOECHO) $(NOOP)'; # eg update MANIFEST
    $self->{POSTOP}   ||= '$(NOECHO) $(NOOP)'; # eg remove the distdir
    $self->{TO_UNIX}  ||= '$(NOECHO) $(NOOP)';

    $self->{CI}       ||= 'ci -u';
    $self->{RCS_LABEL}||= 'rcs -Nv$(VERSION_SYM): -q';
    $self->{DIST_CP}  ||= 'best';
    $self->{DIST_DEFAULT} ||= 'tardist';

    ($self->{DISTNAME} = $self->{NAME}) =~ s{::}{-}g unless $self->{DISTNAME};
    $self->{DISTVNAME} ||= $self->{DISTNAME}.'-'.$self->{VERSION};
}

=item dist (o)

  my $dist_macros = $mm->dist(%overrides);

Generates a make fragment defining all the macros initialized in
init_dist.

%overrides can be used to override any of the above.

=cut

sub dist {
    my($self, %attribs) = @_;

    my $make = '';
    if ( $attribs{SUFFIX} && $attribs{SUFFIX} !~ m!^\.! ) {
      $attribs{SUFFIX} = '.' . $attribs{SUFFIX};
    }
    foreach my $key (qw(
            TAR TARFLAGS ZIP ZIPFLAGS COMPRESS SUFFIX SHAR
            PREOP POSTOP TO_UNIX
            CI RCS_LABEL DIST_CP DIST_DEFAULT
            DISTNAME DISTVNAME
           ))
    {
        my $value = $attribs{$key} || $self->{$key};
        $make .= "$key = $value\n";
    }

    return $make;
}

=item dist_basics (o)

Defines the targets distclean, distcheck, skipcheck, manifest, veryclean.

=cut

sub dist_basics {
    my($self) = shift;

    return <<'MAKE_FRAG';
distclean :: realclean distcheck
	$(NOECHO) $(NOOP)

distcheck :
	$(PERLRUN) "-MExtUtils::Manifest=fullcheck" -e fullcheck

skipcheck :
	$(PERLRUN) "-MExtUtils::Manifest=skipcheck" -e skipcheck

manifest :
	$(PERLRUN) "-MExtUtils::Manifest=mkmanifest" -e mkmanifest

veryclean : realclean
	$(RM_F) *~ */*~ *.orig */*.orig *.bak */*.bak *.old */*.old

MAKE_FRAG

}

=item dist_ci (o)

Defines a check in target for RCS.

=cut

sub dist_ci {
    my($self) = shift;
    return sprintf "ci :\n\t%s\n", $self->oneliner(<<'EOF', [qw(-MExtUtils::Manifest=maniread)]);
@all = sort keys %{ maniread() };
print(qq{Executing $(CI) @all\n});
system(qq{$(CI) @all}) == 0 or die $!;
print(qq{Executing $(RCS_LABEL) ...\n});
system(qq{$(RCS_LABEL) @all}) == 0 or die $!;
EOF
}

=item dist_core (o)

  my $dist_make_fragment = $MM->dist_core;

Puts the targets necessary for 'make dist' together into one make
fragment.

=cut

sub dist_core {
    my($self) = shift;

    my $make_frag = '';
    foreach my $target (qw(dist tardist uutardist tarfile zipdist zipfile
                           shdist))
    {
        my $method = $target.'_target';
        $make_frag .= "\n";
        $make_frag .= $self->$method();
    }

    return $make_frag;
}


=item B<dist_target>

  my $make_frag = $MM->dist_target;

Returns the 'dist' target to make an archive for distribution.  This
target simply checks to make sure the Makefile is up-to-date and
depends on $(DIST_DEFAULT).

=cut

sub dist_target {
    my($self) = shift;

    my $date_check = $self->oneliner(<<'CODE', ['-l']);
print 'Warning: Makefile possibly out of date with $(VERSION_FROM)'
    if -e '$(VERSION_FROM)' and -M '$(VERSION_FROM)' < -M '$(FIRST_MAKEFILE)';
CODE

    return sprintf <<'MAKE_FRAG', $date_check;
dist : $(DIST_DEFAULT) $(FIRST_MAKEFILE)
	$(NOECHO) %s
MAKE_FRAG
}

=item B<tardist_target>

  my $make_frag = $MM->tardist_target;

Returns the 'tardist' target which is simply so 'make tardist' works.
The real work is done by the dynamically named tardistfile_target()
method, tardist should have that as a dependency.

=cut

sub tardist_target {
    my($self) = shift;

    return <<'MAKE_FRAG';
tardist : $(DISTVNAME).tar$(SUFFIX)
	$(NOECHO) $(NOOP)
MAKE_FRAG
}

=item B<zipdist_target>

  my $make_frag = $MM->zipdist_target;

Returns the 'zipdist' target which is simply so 'make zipdist' works.
The real work is done by the dynamically named zipdistfile_target()
method, zipdist should have that as a dependency.

=cut

sub zipdist_target {
    my($self) = shift;

    return <<'MAKE_FRAG';
zipdist : $(DISTVNAME).zip
	$(NOECHO) $(NOOP)
MAKE_FRAG
}

=item B<tarfile_target>

  my $make_frag = $MM->tarfile_target;

The name of this target is the name of the tarball generated by
tardist.  This target does the actual work of turning the distdir into
a tarball.

=cut

sub tarfile_target {
    my($self) = shift;

    return <<'MAKE_FRAG';
$(DISTVNAME).tar$(SUFFIX) : distdir
	$(PREOP)
	$(TO_UNIX)
	$(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
	$(RM_RF) $(DISTVNAME)
	$(COMPRESS) $(DISTVNAME).tar
	$(NOECHO) $(ECHO) 'Created $(DISTVNAME).tar$(SUFFIX)'
	$(POSTOP)
MAKE_FRAG
}

=item zipfile_target

  my $make_frag = $MM->zipfile_target;

The name of this target is the name of the zip file generated by
zipdist.  This target does the actual work of turning the distdir into
a zip file.

=cut

sub zipfile_target {
    my($self) = shift;

    return <<'MAKE_FRAG';
$(DISTVNAME).zip : distdir
	$(PREOP)
	$(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
	$(RM_RF) $(DISTVNAME)
	$(NOECHO) $(ECHO) 'Created $(DISTVNAME).zip'
	$(POSTOP)
MAKE_FRAG
}

=item uutardist_target

  my $make_frag = $MM->uutardist_target;

Converts the tarfile into a uuencoded file

=cut

sub uutardist_target {
    my($self) = shift;

    return <<'MAKE_FRAG';
uutardist : $(DISTVNAME).tar$(SUFFIX)
	uuencode $(DISTVNAME).tar$(SUFFIX) $(DISTVNAME).tar$(SUFFIX) > $(DISTVNAME).tar$(SUFFIX)_uu
	$(NOECHO) $(ECHO) 'Created $(DISTVNAME).tar$(SUFFIX)_uu'
MAKE_FRAG
}


=item shdist_target

  my $make_frag = $MM->shdist_target;

Converts the distdir into a shell archive.

=cut

sub shdist_target {
    my($self) = shift;

    return <<'MAKE_FRAG';
shdist : distdir
	$(PREOP)
	$(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
	$(RM_RF) $(DISTVNAME)
	$(NOECHO) $(ECHO) 'Created $(DISTVNAME).shar'
	$(POSTOP)
MAKE_FRAG
}


=item dlsyms (o)

Used by some OS' to define DL_FUNCS and DL_VARS and write the *.exp files.

Normally just returns an empty string.

=cut

sub dlsyms {
    return '';
}


=item dynamic_bs (o)

Defines targets for bootstrap files.

=cut

sub dynamic_bs {
    my($self, %attribs) = @_;
    return "\nBOOTSTRAP =\n" unless $self->has_link_code();
    my @exts;
    if ($self->{XSMULTI}) {
	@exts = $self->_xs_list_basenames;
    } else {
	@exts = '$(BASEEXT)';
    }
    return join "\n",
        "BOOTSTRAP = @{[map { qq{$_.bs} } @exts]}\n",
        map { $self->_xs_make_bs($_) } @exts;
}

sub _xs_make_bs {
    my ($self, $basename) = @_;
    my ($v, $d, $f) = File::Spec->splitpath($basename);
    my @d = File::Spec->splitdir($d);
    shift @d if $self->{XSMULTI} and $d[0] eq 'lib';
    my $instdir = $self->catdir('$(INST_ARCHLIB)', 'auto', @d, $f);
    $instdir = '$(INST_ARCHAUTODIR)' if $basename eq '$(BASEEXT)';
    my $instfile = $self->catfile($instdir, "$f.bs");
    my $exists = "$instdir\$(DFSEP).exists"; # match blibdirs_target
    #                                 1          2          3
    return _sprintf562 <<'MAKE_FRAG', $basename, $instfile, $exists;
# As Mkbootstrap might not write a file (if none is required)
# we use touch to prevent make continually trying to remake it.
# The DynaLoader only reads a non-empty file.
%1$s.bs : $(FIRST_MAKEFILE) $(BOOTDEP)
	$(NOECHO) $(ECHO) "Running Mkbootstrap for %1$s ($(BSLOADLIBS))"
	$(NOECHO) $(PERLRUN) \
		"-MExtUtils::Mkbootstrap" \
		-e "Mkbootstrap('%1$s','$(BSLOADLIBS)');"
	$(NOECHO) $(TOUCH) "%1$s.bs"
	$(CHMOD) $(PERM_RW) "%1$s.bs"

%2$s : %1$s.bs %3$s
	$(NOECHO) $(RM_RF) %2$s
	- $(CP_NONEMPTY) %1$s.bs %2$s $(PERM_RW)
MAKE_FRAG
}

=item dynamic_lib (o)

Defines how to produce the *.so (or equivalent) files.

=cut

sub dynamic_lib {
    my($self, %attribs) = @_;
    return '' unless $self->needs_linking(); #might be because of a subdir
    return '' unless $self->has_link_code;
    my @m = $self->xs_dynamic_lib_macros(\%attribs);
    my @libs;
    my $dlsyms_ext = eval { $self->xs_dlsyms_ext };
    if ($self->{XSMULTI}) {
        my @exts = $self->_xs_list_basenames;
        for my $ext (@exts) {
            my ($v, $d, $f) = File::Spec->splitpath($ext);
            my @d = File::Spec->splitdir($d);
            shift @d if $d[0] eq 'lib';
            pop @d if $d[$#d] eq '';
            my $instdir = $self->catdir('$(INST_ARCHLIB)', 'auto', @d, $f);

            # Dynamic library names may need special handling.
            eval { require DynaLoader };
            if (defined &DynaLoader::mod2fname) {
                $f = &DynaLoader::mod2fname([@d, $f]);
            }

            my $instfile = $self->catfile($instdir, "$f.\$(DLEXT)");
            my $objfile = $self->_xsbuild_value('xs', $ext, 'OBJECT');
            $objfile = "$ext\$(OBJ_EXT)" unless defined $objfile;
            my $ldfrom = $self->_xsbuild_value('xs', $ext, 'LDFROM');
            $ldfrom = $objfile unless defined $ldfrom;
            my $exportlist = "$ext.def";
            my @libchunk = ($objfile, $instfile, $instdir, $ldfrom, $exportlist);
            push @libchunk, $dlsyms_ext ? $ext.$dlsyms_ext : undef;
            push @libs, \@libchunk;
        }
    } else {
        my @libchunk = qw($(OBJECT) $(INST_DYNAMIC) $(INST_ARCHAUTODIR) $(LDFROM) $(EXPORT_LIST));
        push @libchunk, $dlsyms_ext ? '$(BASEEXT)'.$dlsyms_ext : undef;
        @libs = (\@libchunk);
    }
    push @m, map { $self->xs_make_dynamic_lib(\%attribs, @$_); } @libs;

    return join("\n",@m);
}

=item xs_dynamic_lib_macros

Defines the macros for the C<dynamic_lib> section.

=cut

sub xs_dynamic_lib_macros {
    my ($self, $attribs) = @_;
    my $otherldflags = $attribs->{OTHERLDFLAGS} || "";
    my $inst_dynamic_dep = $attribs->{INST_DYNAMIC_DEP} || "";
    my $armaybe = $self->_xs_armaybe($attribs);
    my $ld_opt = $Is{OS2} ? '$(OPTIMIZE) ' : ''; # Useful on other systems too?
    my $ld_fix = $Is{OS2} ? '|| ( $(RM_F) $@ && sh -c false )' : '';
    sprintf <<'EOF', $armaybe, $ld_opt.$otherldflags, $inst_dynamic_dep, $ld_fix;
# This section creates the dynamically loadable objects from relevant
# objects and possibly $(MYEXTLIB).
ARMAYBE = %s
OTHERLDFLAGS = %s
INST_DYNAMIC_DEP = %s
INST_DYNAMIC_FIX = %s
EOF
}

sub _xs_armaybe {
    my ($self, $attribs) = @_;
    my $armaybe = $attribs->{ARMAYBE} || $self->{ARMAYBE} || ":";
    $armaybe = 'ar' if ($Is{OSF} and $armaybe eq ':');
    $armaybe;
}

=item xs_make_dynamic_lib

Defines the recipes for the C<dynamic_lib> section.

=cut

sub xs_make_dynamic_lib {
    my ($self, $attribs, $object, $to, $todir, $ldfrom, $exportlist, $dlsyms) = @_;
    $exportlist = '' if $exportlist ne '$(EXPORT_LIST)';
    my $armaybe = $self->_xs_armaybe($attribs);
    my @m = sprintf '%s : %s $(MYEXTLIB) %s$(DFSEP).exists %s $(PERL_ARCHIVEDEP) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP) %s'."\n", $to, $object, $todir, $exportlist, ($dlsyms || '');
    my $dlsyms_arg = $self->xs_dlsyms_arg($dlsyms);
    if ($armaybe ne ':'){
        $ldfrom = 'tmp$(LIB_EXT)';
        push(@m,"	\$(ARMAYBE) cr $ldfrom $object\n");
        push(@m,"	\$(RANLIB) $ldfrom\n");
    }
    $ldfrom = "-all $ldfrom -none" if $Is{OSF};

    my $ldrun = '';
    # The IRIX linker doesn't use LD_RUN_PATH
    if ( $self->{LD_RUN_PATH} ) {
        if ( $Is{IRIX} ) {
            $ldrun = qq{-rpath "$self->{LD_RUN_PATH}"};
        }
        elsif ( $^O eq 'darwin' ) {
            # both clang and gcc support -Wl,-rpath, but only clang supports
            # -rpath so by using -Wl,-rpath we avoid having to check for the
            # type of compiler
            $ldrun = qq{-Wl,-rpath,"$self->{LD_RUN_PATH}"};
        }
    }

    # For example in AIX the shared objects/libraries from previous builds
    # linger quite a while in the shared dynalinker cache even when nobody
    # is using them.  This is painful if one for instance tries to restart
    # a failed build because the link command will fail unnecessarily 'cos
    # the shared object/library is 'busy'.
    push(@m,"	\$(RM_F) \$\@\n");

    my $libs = '$(LDLOADLIBS)';
    if (($Is{NetBSD} || $Is{Interix} || $Is{Android}) && $Config{'useshrplib'} eq 'true') {
        # Use nothing on static perl platforms, and to the flags needed
        # to link against the shared libperl library on shared perl
        # platforms.  We peek at lddlflags to see if we need -Wl,-R
        # or -R to add paths to the run-time library search path.
        if ($Config{'lddlflags'} =~ /-Wl,-R/) {
            $libs .= ' "-L$(PERL_INC)" "-Wl,-R$(INSTALLARCHLIB)/CORE" "-Wl,-R$(PERL_ARCHLIB)/CORE" -lperl';
        } elsif ($Config{'lddlflags'} =~ /-R/) {
            $libs .= ' "-L$(PERL_INC)" "-R$(INSTALLARCHLIB)/CORE" "-R$(PERL_ARCHLIB)/CORE" -lperl';
        } elsif ( $Is{Android} ) {
            # The Android linker will not recognize symbols from
            # libperl unless the module explicitly depends on it.
            $libs .= ' "-L$(PERL_INC)" -lperl';
        }
    }

    my $ld_run_path_shell = "";
    if ($self->{LD_RUN_PATH} ne "") {
        $ld_run_path_shell = 'LD_RUN_PATH="$(LD_RUN_PATH)" ';
    }

    push @m, sprintf <<'MAKE', $ld_run_path_shell, $ldrun, $dlsyms_arg, $ldfrom, $self->xs_obj_opt('$@'), $libs, $exportlist;
	%s$(LD) %s $(LDDLFLAGS) %s %s $(OTHERLDFLAGS) %s $(MYEXTLIB) \
	  $(PERL_ARCHIVE) %s $(PERL_ARCHIVE_AFTER) %s \
	  $(INST_DYNAMIC_FIX)
	$(CHMOD) $(PERM_RWX) $@
MAKE
    join '', @m;
}

=item exescan

Deprecated method. Use libscan instead.

=cut

sub exescan {
    my($self,$path) = @_;
    $path;
}

=item extliblist

Called by init_others, and calls ext ExtUtils::Liblist. See
L<ExtUtils::Liblist> for details.

=cut

sub extliblist {
    my($self,$libs) = @_;
    require ExtUtils::Liblist;
    $self->ext($libs, $Verbose);
}

=item find_perl

Finds the executables PERL and FULLPERL

=cut

sub find_perl {
    my($self, $ver, $names, $dirs, $trace) = @_;
    if ($trace >= 2){
        print "Looking for perl $ver by these names:
@$names
in these dirs:
@$dirs
";
    }

    my $stderr_duped = 0;
    local *STDERR_COPY;

    unless ($Is{BSD}) {
        # >& and lexical filehandles together give 5.6.2 indigestion
        if( open(STDERR_COPY, '>&STDERR') ) {  ## no critic
            $stderr_duped = 1;
        }
        else {
            warn <<WARNING;
find_perl() can't dup STDERR: $!
You might see some garbage while we search for Perl
WARNING
        }
    }

    foreach my $name (@$names){
        my ($abs, $use_dir);
        if ($self->file_name_is_absolute($name)) {     # /foo/bar
            $abs = $name;
        } elsif ($self->canonpath($name) eq
                 $self->canonpath(basename($name))) {  # foo
            $use_dir = 1;
        } else {                                            # foo/bar
            $abs = $self->catfile($Curdir, $name);
        }
        foreach my $dir ($use_dir ? @$dirs : 1){
            next unless defined $dir; # $self->{PERL_SRC} may be undefined

            $abs = $self->catfile($dir, $name)
                if $use_dir;

            print "Checking $abs\n" if ($trace >= 2);
            next unless $self->maybe_command($abs);
            print "Executing $abs\n" if ($trace >= 2);

            my $val;
            my $version_check = qq{"$abs" -le "require $ver; print qq{VER_OK}"};

            # To avoid using the unportable 2>&1 to suppress STDERR,
            # we close it before running the command.
            # However, thanks to a thread library bug in many BSDs
            # ( http://www.freebsd.org/cgi/query-pr.cgi?pr=51535 )
            # we cannot use the fancier more portable way in here
            # but instead need to use the traditional 2>&1 construct.
            if ($Is{BSD}) {
                $val = `$version_check 2>&1`;
            } else {
                close STDERR if $stderr_duped;
                $val = `$version_check`;

                # 5.6.2's 3-arg open doesn't work with >&
                open STDERR, ">&STDERR_COPY"  ## no critic
                        if $stderr_duped;
            }

            if ($val =~ /^VER_OK/m) {
                print "Using PERL=$abs\n" if $trace;
                return $abs;
            } elsif ($trace >= 2) {
                print "Result: '$val' ".($? >> 8)."\n";
            }
        }
    }
    print "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
    0; # false and not empty
}


=item fixin

  $mm->fixin(@files);

Inserts the sharpbang or equivalent magic number to a set of @files.

=cut

sub fixin {    # stolen from the pink Camel book, more or less
    my ( $self, @files ) = @_;

    for my $file (@files) {
        my $file_new = "$file.new";
        my $file_bak = "$file.bak";

        open( my $fixin, '<', $file ) or croak "Can't process '$file': $!";
        local $/ = "\n";
        chomp( my $line = <$fixin> );
        next unless $line =~ s/^\s*\#!\s*//;    # Not a shebang file.

        my $shb = $self->_fixin_replace_shebang( $file, $line );
        next unless defined $shb;

        open( my $fixout, ">", "$file_new" ) or do {
            warn "Can't create new $file: $!\n";
            next;
        };

        # Print out the new #! line (or equivalent).
        local $\;
        local $/;
        print $fixout $shb, <$fixin>;
        close $fixin;
        close $fixout;

        chmod 0666, $file_bak;
        unlink $file_bak;
        unless ( _rename( $file, $file_bak ) ) {
            warn "Can't rename $file to $file_bak: $!";
            next;
        }
        unless ( _rename( $file_new, $file ) ) {
            warn "Can't rename $file_new to $file: $!";
            unless ( _rename( $file_bak, $file ) ) {
                warn "Can't rename $file_bak back to $file either: $!";
                warn "Leaving $file renamed as $file_bak\n";
            }
            next;
        }
        unlink $file_bak;
    }
    continue {
        system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';
    }
}


sub _rename {
    my($old, $new) = @_;

    foreach my $file ($old, $new) {
        if( $Is{VMS} and basename($file) !~ /\./ ) {
            # rename() in 5.8.0 on VMS will not rename a file if it
            # does not contain a dot yet it returns success.
            $file = "$file.";
        }
    }

    return rename($old, $new);
}

sub _fixin_replace_shebang {
    my ( $self, $file, $line ) = @_;

    # Now figure out the interpreter name.
    my ( $origcmd, $arg ) = split ' ', $line, 2;
    (my $cmd = $origcmd) =~ s!^.*/!!;

    # Now look (in reverse) for interpreter in absolute PATH (unless perl).
    my $interpreter;
    if ( defined $ENV{PERL_MM_SHEBANG} && $ENV{PERL_MM_SHEBANG} eq "relocatable" ) {
        $interpreter = "/usr/bin/env perl";
    }
    elsif ( $cmd =~ m{^perl(?:\z|[^a-z])} ) {
        if ( $Config{startperl} =~ m,^\#!.*/perl, ) {
            $interpreter = $Config{startperl};
            $interpreter =~ s,^\#!,,;
        }
        else {
            $interpreter = $Config{perlpath};
        }
    }
    else {
        my (@absdirs)
            = reverse grep { $self->file_name_is_absolute($_) } $self->path;
        $interpreter = '';

        foreach my $dir (@absdirs) {
            my $maybefile = $self->catfile($dir,$cmd);
            if ( $self->maybe_command($maybefile) ) {
                warn "Ignoring $interpreter in $file\n"
                    if $Verbose && $interpreter;
                $interpreter = $maybefile;
            }
        }

        # If the shebang is absolute and exists in PATH, but was not
        # the first one found, leave it alone if it's actually the
        # same file as first one.  This avoids packages built on
        # merged-/usr systems with /usr/bin before /bin in the path
        # breaking when installed on systems without merged /usr
        if ($origcmd ne $interpreter and $self->file_name_is_absolute($origcmd)) {
            my $origdir = dirname($origcmd);
            if ($self->maybe_command($origcmd) && grep { $_ eq $origdir } @absdirs) {
                my ($odev, $oino) = stat $origcmd;
                my ($idev, $iino) = stat $interpreter;
                if ($odev == $idev && $oino eq $iino) {
                    warn "$origcmd is the same as $interpreter, leaving alone"
                        if $Verbose;
                    $interpreter = $origcmd;
                }
            }
        }
    }

    # Figure out how to invoke interpreter on this machine.

    my ($does_shbang) = $Config{'sharpbang'} =~ /^\s*\#\!/;
    my ($shb) = "";
    if ($interpreter) {
        print "Changing sharpbang in $file to $interpreter"
            if $Verbose;
         # this is probably value-free on DOSISH platforms
        if ($does_shbang) {
            $shb .= "$Config{'sharpbang'}$interpreter";
            $shb .= ' ' . $arg if defined $arg;
            $shb .= "\n";
        }
    }
    else {
        warn "Can't find $cmd in PATH, $file unchanged"
            if $Verbose;
        return;
    }
    return $shb
}

=item force (o)

Writes an empty FORCE: target.

=cut

sub force {
    my($self) = shift;
    '# Phony target to force checking subdirectories.
FORCE :
	$(NOECHO) $(NOOP)
';
}

=item guess_name

Guess the name of this package by examining the working directory's
name. MakeMaker calls this only if the developer has not supplied a
NAME attribute.

=cut

# ';

sub guess_name {
    my($self) = @_;
    use Cwd 'cwd';
    my $name = basename(cwd());
    $name =~ s|[\-_][\d\.\-]+\z||;  # this is new with MM 5.00, we
                                    # strip minus or underline
                                    # followed by a float or some such
    print "Warning: Guessing NAME [$name] from current directory name.\n";
    $name;
}

=item has_link_code

Returns true if C, XS, MYEXTLIB or similar objects exist within this
object that need a compiler. Does not descend into subdirectories as
needs_linking() does.

=cut

sub has_link_code {
    my($self) = shift;
    return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
    if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
	$self->{HAS_LINK_CODE} = 1;
	return 1;
    }
    return $self->{HAS_LINK_CODE} = 0;
}


=item init_dirscan

Scans the directory structure and initializes DIR, XS, XS_FILES,
C, C_FILES, O_FILES, H, H_FILES, PL_FILES, EXE_FILES.

Called by init_main.

=cut

sub init_dirscan {	# --- File and Directory Lists (.xs .pm .pod etc)
    my($self) = @_;
    my(%dir, %xs, %c, %o, %h, %pl_files, %pm);

    my %ignore = map {( $_ => 1 )} qw(Makefile.PL Build.PL test.pl t);

    # ignore the distdir
    $Is{VMS} ? $ignore{"$self->{DISTVNAME}.dir"} = 1
            : $ignore{$self->{DISTVNAME}} = 1;

    my $distprefix = $Is{VMS} ? qr/^\Q$self->{DISTNAME}\E-v?[\d\.]+\.dir$/i
                              : qr/^\Q$self->{DISTNAME}\E-v?[\d\.]+$/;

    @ignore{map lc, keys %ignore} = values %ignore if $Is{VMS};

    if ( defined $self->{XS} and !defined $self->{C} ) {
	my @c_files = grep { m/\.c(pp|xx)?\z/i } values %{$self->{XS}};
	my @o_files = grep { m/(?:.(?:o(?:bj)?)|\$\(OBJ_EXT\))\z/i } values %{$self->{XS}};
	%c = map { $_ => 1 } @c_files;
	%o = map { $_ => 1 } @o_files;
    }

    foreach my $name ($self->lsdir($Curdir)){
	next if $name =~ /\#/;
	next if $name =~ $distprefix && -d $name;
	$name = lc($name) if $Is{VMS};
	next if $name eq $Curdir or $name eq $Updir or $ignore{$name};
	next unless $self->libscan($name);
	if (-d $name){
	    next if -l $name; # We do not support symlinks at all
            next if $self->{NORECURS};
	    $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
	} elsif ($name =~ /\.xs\z/){
	    my($c); ($c = $name) =~ s/\.xs\z/.c/;
	    $xs{$name} = $c;
	    $c{$c} = 1;
	} elsif ($name =~ /\.c(pp|xx|c)?\z/i){  # .c .C .cpp .cxx .cc
	    $c{$name} = 1
		unless $name =~ m/perlmain\.c/; # See MAP_TARGET
	} elsif ($name =~ /\.h\z/i){
	    $h{$name} = 1;
	} elsif ($name =~ /\.PL\z/) {
	    ($pl_files{$name} = $name) =~ s/\.PL\z// ;
	} elsif (($Is{VMS} || $Is{Dos}) && $name =~ /[._]pl$/i) {
	    # case-insensitive filesystem, one dot per name, so foo.h.PL
	    # under Unix appears as foo.h_pl under VMS or fooh.pl on Dos
	    local($/); open(my $pl, '<', $name); my $txt = <$pl>; close $pl;
	    if ($txt =~ /Extracting \S+ \(with variable substitutions/) {
		($pl_files{$name} = $name) =~ s/[._]pl\z//i ;
	    }
	    else {
                $pm{$name} = $self->catfile($self->{INST_LIBDIR},$name);
            }
	} elsif ($name =~ /\.(p[ml]|pod)\z/){
	    $pm{$name} = $self->catfile($self->{INST_LIBDIR},$name);
	}
    }

    $self->{PL_FILES}   ||= \%pl_files;
    $self->{DIR}        ||= [sort keys %dir];
    $self->{XS}         ||= \%xs;
    $self->{C}          ||= [sort keys %c];
    $self->{H}          ||= [sort keys %h];
    $self->{PM}         ||= \%pm;

    my @o_files = @{$self->{C}};
    %o = (%o, map { $_ => 1 } grep s/\.c(pp|xx|c)?\z/$self->{OBJ_EXT}/i, @o_files);
    $self->{O_FILES} = [sort keys %o];
}


=item init_MANPODS

Determines if man pages should be generated and initializes MAN1PODS
and MAN3PODS as appropriate.

=cut

sub init_MANPODS {
    my $self = shift;

    # Set up names of manual pages to generate from pods
    foreach my $man (qw(MAN1 MAN3)) {
        if ( $self->{"${man}PODS"}
             or $self->{"INSTALL${man}DIR"} =~ /^(none|\s*)$/
        ) {
            $self->{"${man}PODS"} ||= {};
        }
        else {
            my $init_method = "init_${man}PODS";
            $self->$init_method();
        }
    }

    # logic similar to picking man${num}ext in perl's Configure script
    foreach my $num (1,3) {
        my $installdirs = uc $self->{INSTALLDIRS};
        $installdirs = '' if $installdirs eq 'PERL';
        my @mandirs = File::Spec->splitdir( $self->_expand_macros(
            $self->{ "INSTALL${installdirs}MAN${num}DIR" } ) );
        my $mandir = pop @mandirs;
        my $section = $num;

        foreach ($num, "${num}p", "${num}pm", qw< l n o C L >, "L$num") {
            if ( $mandir =~ /^(?:man|cat)$_$/ ) {
                $section = $_;
                last;
            }
        }

        $self->{"MAN${num}SECTION"} = $section;
    }
}


sub _has_pod {
    my($self, $file) = @_;

    my($ispod)=0;
    if (open( my $fh, '<', $file )) {
        while (<$fh>) {
            if (/^=(?:head\d+|item|pod)\b/) {
                $ispod=1;
                last;
            }
        }
        close $fh;
    } else {
        # If it doesn't exist yet, we assume, it has pods in it
        $ispod = 1;
    }

    return $ispod;
}


=item init_MAN1PODS

Initializes MAN1PODS from the list of EXE_FILES.

=cut

sub init_MAN1PODS {
    my($self) = @_;

    if ( exists $self->{EXE_FILES} ) {
	foreach my $name (@{$self->{EXE_FILES}}) {
	    next unless $self->_has_pod($name);

	    $self->{MAN1PODS}->{$name} =
		$self->catfile("\$(INST_MAN1DIR)",
			       basename($name).".\$(MAN1EXT)");
	}
    }
}


=item init_MAN3PODS

Initializes MAN3PODS from the list of PM files.

=cut

sub init_MAN3PODS {
    my $self = shift;

    my %manifypods = (); # we collect the keys first, i.e. the files
                         # we have to convert to pod

    foreach my $name (keys %{$self->{PM}}) {
	if ($name =~ /\.pod\z/ ) {
	    $manifypods{$name} = $self->{PM}{$name};
	} elsif ($name =~ /\.p[ml]\z/ ) {
	    if( $self->_has_pod($name) ) {
		$manifypods{$name} = $self->{PM}{$name};
	    }
	}
    }

    my $parentlibs_re = join '|', @{$self->{PMLIBPARENTDIRS}};

    # Remove "Configure.pm" and similar, if it's not the only pod listed
    # To force inclusion, just name it "Configure.pod", or override
    # MAN3PODS
    foreach my $name (keys %manifypods) {
	if (
            ($self->{PERL_CORE} and $name =~ /(config|setup).*\.pm/is) or
            ( $name =~ m/^README\.pod$/i ) # don't manify top-level README.pod
        ) {
	    delete $manifypods{$name};
	    next;
	}
	my($manpagename) = $name;
	$manpagename =~ s/\.p(od|m|l)\z//;
	# everything below lib is ok
	unless($manpagename =~ s!^\W*($parentlibs_re)\W+!!s) {
	    $manpagename = $self->catfile(
	        split(/::/,$self->{PARENT_NAME}),$manpagename
	    );
	}
	$manpagename = $self->replace_manpage_separator($manpagename);
	$self->{MAN3PODS}->{$name} =
	    $self->catfile("\$(INST_MAN3DIR)", "$manpagename.\$(MAN3EXT)");
    }
}


=item init_PM

Initializes PMLIBDIRS and PM from PMLIBDIRS.

=cut

sub init_PM {
    my $self = shift;

    # Some larger extensions often wish to install a number of *.pm/pl
    # files into the library in various locations.

    # The attribute PMLIBDIRS holds an array reference which lists
    # subdirectories which we should search for library files to
    # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ].  We
    # recursively search through the named directories (skipping any
    # which don't exist or contain Makefile.PL files).

    # For each *.pm or *.pl file found $self->libscan() is called with
    # the default installation path in $_[1]. The return value of
    # libscan defines the actual installation location.  The default
    # libscan function simply returns the path.  The file is skipped
    # if libscan returns false.

    # The default installation location passed to libscan in $_[1] is:
    #
    #  ./*.pm		=> $(INST_LIBDIR)/*.pm
    #  ./xyz/...	=> $(INST_LIBDIR)/xyz/...
    #  ./lib/...	=> $(INST_LIB)/...
    #
    # In this way the 'lib' directory is seen as the root of the actual
    # perl library whereas the others are relative to INST_LIBDIR
    # (which includes PARENT_NAME). This is a subtle distinction but one
    # that's important for nested modules.

    unless( $self->{PMLIBDIRS} ) {
        if( $Is{VMS} ) {
            # Avoid logical name vs directory collisions
            $self->{PMLIBDIRS} = ['./lib', "./$self->{BASEEXT}"];
        }
        else {
            $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}];
        }
    }

    #only existing directories that aren't in $dir are allowed

    # Avoid $_ wherever possible:
    # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
    my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
    @{$self->{PMLIBDIRS}} = ();
    my %dir = map { ($_ => $_) } @{$self->{DIR}};
    foreach my $pmlibdir (@pmlibdirs) {
	-d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
    }

    unless( $self->{PMLIBPARENTDIRS} ) {
	@{$self->{PMLIBPARENTDIRS}} = ('lib');
    }

    return if $self->{PM} and $self->{ARGS}{PM};

    if (@{$self->{PMLIBDIRS}}){
	print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
	    if ($Verbose >= 2);
	require File::Find;
        File::Find::find(sub {
            if (-d $_){
                unless ($self->libscan($_)){
                    $File::Find::prune = 1;
                }
                return;
            }
            return if /\#/;
            return if /~$/;             # emacs temp files
            return if /,v$/;            # RCS files
            return if m{\.swp$};        # vim swap files

	    my $path   = $File::Find::name;
            my $prefix = $self->{INST_LIBDIR};
            my $striplibpath;

	    my $parentlibs_re = join '|', @{$self->{PMLIBPARENTDIRS}};
	    $prefix =  $self->{INST_LIB}
                if ($striplibpath = $path) =~ s{^(\W*)($parentlibs_re)\W}
	                                       {$1}i;

	    my($inst) = $self->catfile($prefix,$striplibpath);
	    local($_) = $inst; # for backwards compatibility
	    $inst = $self->libscan($inst);
	    print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
	    return unless $inst;
	    if ($self->{XSMULTI} and $inst =~ /\.xs\z/) {
		my($base); ($base = $path) =~ s/\.xs\z//;
		$self->{XS}{$path} = "$base.c";
		push @{$self->{C}}, "$base.c";
		push @{$self->{O_FILES}}, "$base$self->{OBJ_EXT}";
	    } else {
		$self->{PM}{$path} = $inst;
	    }
	}, @{$self->{PMLIBDIRS}});
    }
}


=item init_DIRFILESEP

Using / for Unix.  Called by init_main.

=cut

sub init_DIRFILESEP {
    my($self) = shift;

    $self->{DIRFILESEP} = '/';
}


=item init_main

Initializes AR, AR_STATIC_ARGS, BASEEXT, CONFIG, DISTNAME, DLBASE,
EXE_EXT, FULLEXT, FULLPERL, FULLPERLRUN, FULLPERLRUNINST, INST_*,
INSTALL*, INSTALLDIRS, LIB_EXT, LIBPERL_A, MAP_TARGET, NAME,
OBJ_EXT, PARENT_NAME, PERL, PERL_ARCHLIB, PERL_INC, PERL_LIB,
PERL_SRC, PERLRUN, PERLRUNINST, PREFIX, VERSION,
VERSION_SYM, XS_VERSION.

=cut

sub init_main {
    my($self) = @_;

    # --- Initialize Module Name and Paths

    # NAME    = Foo::Bar::Oracle
    # FULLEXT = Foo/Bar/Oracle
    # BASEEXT = Oracle
    # PARENT_NAME = Foo::Bar
### Only UNIX:
###    ($self->{FULLEXT} =
###     $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
    $self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME});


    # Copied from DynaLoader:

    my(@modparts) = split(/::/,$self->{NAME});
    my($modfname) = $modparts[-1];

    # Some systems have restrictions on files names for DLL's etc.
    # mod2fname returns appropriate file base name (typically truncated)
    # It may also edit @modparts if required.
    # We require DynaLoader to make sure that mod2fname is loaded
    eval { require DynaLoader };
    if (defined &DynaLoader::mod2fname) {
        $modfname = &DynaLoader::mod2fname(\@modparts);
    }

    ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)\z! ;
    $self->{PARENT_NAME} ||= '';

    if (defined &DynaLoader::mod2fname) {
	# As of 5.001m, dl_os2 appends '_'
	$self->{DLBASE} = $modfname;
    } else {
	$self->{DLBASE} = '$(BASEEXT)';
    }


    # --- Initialize PERL_LIB, PERL_SRC

    # *Real* information: where did we get these two from? ...
    my $inc_config_dir = dirname($INC{'Config.pm'});
    my $inc_carp_dir   = dirname($INC{'Carp.pm'});

    unless ($self->{PERL_SRC}){
        foreach my $dir_count (1..8) { # 8 is the VMS limit for nesting
            my $dir = $self->catdir(($Updir) x $dir_count);

            if (-f $self->catfile($dir,"config_h.SH")   &&
                -f $self->catfile($dir,"perl.h")        &&
                -f $self->catfile($dir,"lib","strict.pm")
            ) {
                $self->{PERL_SRC}=$dir ;
                last;
            }
        }
    }

    warn "PERL_CORE is set but I can't find your PERL_SRC!\n" if
      $self->{PERL_CORE} and !$self->{PERL_SRC};

    if ($self->{PERL_SRC}){
	$self->{PERL_LIB}     ||= $self->catdir("$self->{PERL_SRC}","lib");

        $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
        $self->{PERL_INC}     = ($Is{Win32}) ?
            $self->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};

	# catch a situation that has occurred a few times in the past:
	unless (
		-s $self->catfile($self->{PERL_SRC},'cflags')
		or
		$Is{VMS}
		&&
		-s $self->catfile($self->{PERL_SRC},'vmsish.h')
		or
		$Is{Win32}
	       ){
	    warn qq{
You cannot build extensions below the perl source tree after executing
a 'make clean' in the perl source tree.

To rebuild extensions distributed with the perl source you should
simply Configure (to include those extensions) and then build perl as
normal. After installing perl the source tree can be deleted. It is
not needed for building extensions by running 'perl Makefile.PL'
usually without extra arguments.

It is recommended that you unpack and build additional extensions away
from the perl source tree.
};
	}
    } else {
	# we should also consider $ENV{PERL5LIB} here
        my $old = $self->{PERL_LIB} || $self->{PERL_ARCHLIB} || $self->{PERL_INC};
	$self->{PERL_LIB}     ||= $Config{privlibexp};
	$self->{PERL_ARCHLIB} ||= $Config{archlibexp};
	$self->{PERL_INC}     = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
	my $perl_h;

	if (not -f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))
	    and not $old){
	    # Maybe somebody tries to build an extension with an
	    # uninstalled Perl outside of Perl build tree
	    my $lib;
	    for my $dir (@INC) {
	      $lib = $dir, last if -e $self->catfile($dir, "Config.pm");
	    }
	    if ($lib) {
              # Win32 puts its header files in /perl/src/lib/CORE.
              # Unix leaves them in /perl/src.
	      my $inc = $Is{Win32} ? $self->catdir($lib, "CORE" )
                                  : dirname $lib;
	      if (-e $self->catfile($inc, "perl.h")) {
		$self->{PERL_LIB}	   = $lib;
		$self->{PERL_ARCHLIB}	   = $lib;
		$self->{PERL_INC}	   = $inc;
		$self->{UNINSTALLED_PERL}  = 1;
		print <<EOP;
... Detected uninstalled Perl.  Trying to continue.
EOP
	      }
	    }
	}
    }

    if ($Is{Android}) {
    	# Android fun times!
    	# ../../perl -I../../lib -MFile::Glob -e1 works
    	# ../../../perl -I../../../lib -MFile::Glob -e1 fails to find
    	# the .so for File::Glob.
    	# This always affects core perl, but may also affect an installed
    	# perl built with -Duserelocatableinc.
    	$self->{PERL_LIB} = File::Spec->rel2abs($self->{PERL_LIB});
    	$self->{PERL_ARCHLIB} = File::Spec->rel2abs($self->{PERL_ARCHLIB});
    }
    $self->{PERL_INCDEP} = $self->{PERL_INC};
    $self->{PERL_ARCHLIBDEP} = $self->{PERL_ARCHLIB};

    # We get SITELIBEXP and SITEARCHEXP directly via
    # Get_from_Config. When we are running standard modules, these
    # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
    # set it to "site". I prefer that INSTALLDIRS be set from outside
    # MakeMaker.
    $self->{INSTALLDIRS} ||= "site";

    $self->{MAN1EXT} ||= $Config{man1ext};
    $self->{MAN3EXT} ||= $Config{man3ext};

    # Get some stuff out of %Config if we haven't yet done so
    print "CONFIG must be an array ref\n"
        if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
    $self->{CONFIG} = [] unless (ref $self->{CONFIG});
    push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
    push(@{$self->{CONFIG}}, 'shellflags') if $Config{shellflags};
    my(%once_only);
    foreach my $m (@{$self->{CONFIG}}){
        next if $once_only{$m};
        print "CONFIG key '$m' does not exist in Config.pm\n"
                unless exists $Config{$m};
        $self->{uc $m} ||= $Config{$m};
        $once_only{$m} = 1;
    }

# This is too dangerous:
#    if ($^O eq "next") {
#	$self->{AR} = "libtool";
#	$self->{AR_STATIC_ARGS} = "-o";
#    }
# But I leave it as a placeholder

    $self->{AR_STATIC_ARGS} ||= "cr";

    # These should never be needed
    $self->{OBJ_EXT} ||= '.o';
    $self->{LIB_EXT} ||= '.a';

    $self->{MAP_TARGET} ||= "perl";

    $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";

    # make a simple check if we find strict
    warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
        (strict.pm not found)"
        unless -f $self->catfile("$self->{PERL_LIB}","strict.pm") ||
               $self->{NAME} eq "ExtUtils::MakeMaker";
}

=item init_tools

Initializes tools to use their common (and faster) Unix commands.

=cut

sub init_tools {
    my $self = shift;

    $self->{ECHO}       ||= 'echo';
    $self->{ECHO_N}     ||= 'echo -n';
    $self->{RM_F}       ||= "rm -f";
    $self->{RM_RF}      ||= "rm -rf";
    $self->{TOUCH}      ||= "touch";
    $self->{TEST_F}     ||= "test -f";
    $self->{TEST_S}     ||= "test -s";
    $self->{CP}         ||= "cp";
    $self->{MV}         ||= "mv";
    $self->{CHMOD}      ||= "chmod";
    $self->{FALSE}      ||= 'false';
    $self->{TRUE}       ||= 'true';

    $self->{LD}         ||= 'ld';

    return $self->SUPER::init_tools(@_);

    # After SUPER::init_tools so $Config{shell} has a
    # chance to get set.
    $self->{SHELL}      ||= '/bin/sh';

    return;
}


=item init_linker

Unix has no need of special linker flags.

=cut

sub init_linker {
    my($self) = shift;
    $self->{PERL_ARCHIVE} ||= '';
    $self->{PERL_ARCHIVEDEP} ||= '';
    $self->{PERL_ARCHIVE_AFTER} ||= '';
    $self->{EXPORT_LIST}  ||= '';
}


=begin _protected

=item init_lib2arch

    $mm->init_lib2arch

=end _protected

=cut

sub init_lib2arch {
    my($self) = shift;

    # The user who requests an installation directory explicitly
    # should not have to tell us an architecture installation directory
    # as well. We look if a directory exists that is named after the
    # architecture. If not we take it as a sign that it should be the
    # same as the requested installation directory. Otherwise we take
    # the found one.
    for my $libpair ({l=>"privlib",   a=>"archlib"},
                     {l=>"sitelib",   a=>"sitearch"},
                     {l=>"vendorlib", a=>"vendorarch"},
                    )
    {
        my $lib = "install$libpair->{l}";
        my $Lib = uc $lib;
        my $Arch = uc "install$libpair->{a}";
        if( $self->{$Lib} && ! $self->{$Arch} ){
            my($ilib) = $Config{$lib};

            $self->prefixify($Arch,$ilib,$self->{$Lib});

            unless (-d $self->{$Arch}) {
                print "Directory $self->{$Arch} not found\n"
                  if $Verbose;
                $self->{$Arch} = $self->{$Lib};
            }
            print "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
        }
    }
}


=item init_PERL

    $mm->init_PERL;

Called by init_main.  Sets up ABSPERL, PERL, FULLPERL and all the
*PERLRUN* permutations.

    PERL is allowed to be miniperl
    FULLPERL must be a complete perl

    ABSPERL is PERL converted to an absolute path

    *PERLRUN contains everything necessary to run perl, find it's
         libraries, etc...

    *PERLRUNINST is *PERLRUN + everything necessary to find the
         modules being built.

=cut

sub init_PERL {
    my($self) = shift;

    my @defpath = ();
    foreach my $component ($self->{PERL_SRC}, $self->path(),
                           $Config{binexp})
    {
	push @defpath, $component if defined $component;
    }

    # Build up a set of file names (not command names).
    my $thisperl = $self->canonpath($^X);
    $thisperl .= $Config{exe_ext} unless
                # VMS might have a file version # at the end
      $Is{VMS} ? $thisperl =~ m/$Config{exe_ext}(;\d+)?$/i
              : $thisperl =~ m/$Config{exe_ext}$/i;

    # We need a relative path to perl when in the core.
    $thisperl = $self->abs2rel($thisperl) if $self->{PERL_CORE};

    my @perls = ($thisperl);
    push @perls, map { "$_$Config{exe_ext}" }
                     ("perl$Config{version}", 'perl5', 'perl');

    # miniperl has priority over all but the canonical perl when in the
    # core.  Otherwise its a last resort.
    my $miniperl = "miniperl$Config{exe_ext}";
    if( $self->{PERL_CORE} ) {
        splice @perls, 1, 0, $miniperl;
    }
    else {
        push @perls, $miniperl;
    }

    $self->{PERL} ||=
        $self->find_perl(5.0, \@perls, \@defpath, $Verbose );

    my $perl = $self->{PERL};
    $perl =~ s/^"//;
    my $has_mcr = $perl =~ s/^MCR\s*//;
    my $perlflags = '';
    my $stripped_perl;
    while ($perl) {
	($stripped_perl = $perl) =~ s/"$//;
	last if -x $stripped_perl;
	last unless $perl =~ s/(\s+\S+)$//;
	$perlflags = $1.$perlflags;
    }
    $self->{PERL} = $stripped_perl;
    $self->{PERL} = 'MCR '.$self->{PERL} if $has_mcr || $Is{VMS};

    # When built for debugging, VMS doesn't create perl.exe but ndbgperl.exe.
    my $perl_name = 'perl';
    $perl_name = 'ndbgperl' if $Is{VMS} &&
      defined $Config{usevmsdebug} && $Config{usevmsdebug} eq 'define';

    # XXX This logic is flawed.  If "miniperl" is anywhere in the path
    # it will get confused.  It should be fixed to work only on the filename.
    # Define 'FULLPERL' to be a non-miniperl (used in test: target)
    unless ($self->{FULLPERL}) {
      ($self->{FULLPERL} = $self->{PERL}) =~ s/\Q$miniperl\E$/$perl_name$Config{exe_ext}/i;
      $self->{FULLPERL} = qq{"$self->{FULLPERL}"}.$perlflags;
    }
    # Can't have an image name with quotes, and findperl will have
    # already escaped spaces.
    $self->{FULLPERL} =~ tr/"//d if $Is{VMS};

    # `dmake` can fail for image (aka, executable) names which start with double-quotes
    # * push quote inward by at least one character (or the drive prefix, if present)
    # * including any initial directory separator preserves the `file_name_is_absolute` property
    $self->{FULLPERL} =~ s/^"(\S(:\\|:)?)/$1"/ if $self->is_make_type('dmake');

    # Little hack to get around VMS's find_perl putting "MCR" in front
    # sometimes.
    $self->{ABSPERL} = $self->{PERL};
    $has_mcr = $self->{ABSPERL} =~ s/^MCR\s*//;
    if( $self->file_name_is_absolute($self->{ABSPERL}) ) {
        $self->{ABSPERL} = '$(PERL)';
    }
    else {
        $self->{ABSPERL} = $self->rel2abs($self->{ABSPERL});

        # Quote the perl command if it contains whitespace
        $self->{ABSPERL} = $self->quote_literal($self->{ABSPERL})
          if $self->{ABSPERL} =~ /\s/;

        $self->{ABSPERL} = 'MCR '.$self->{ABSPERL} if $has_mcr;
    }
    $self->{PERL} = qq{"$self->{PERL}"}.$perlflags;

    # Can't have an image name with quotes, and findperl will have
    # already escaped spaces.
    $self->{PERL} =~ tr/"//d if $Is{VMS};

    # `dmake` can fail for image (aka, executable) names which start with double-quotes
    # * push quote inward by at least one character (or the drive prefix, if present)
    # * including any initial directory separator preserves the `file_name_is_absolute` property
    $self->{PERL} =~ s/^"(\S(:\\|:)?)/$1"/ if $self->is_make_type('dmake');

    # Are we building the core?
    $self->{PERL_CORE} = $ENV{PERL_CORE} unless exists $self->{PERL_CORE};
    $self->{PERL_CORE} = 0               unless defined $self->{PERL_CORE};

    # Make sure perl can find itself before it's installed.
    my $lib_paths = $self->{UNINSTALLED_PERL} || $self->{PERL_CORE}
        ? ( $self->{PERL_ARCHLIB} && $self->{PERL_LIB} && $self->{PERL_ARCHLIB} ne $self->{PERL_LIB} ) ?
            q{ "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)"} : q{ "-I$(PERL_LIB)"}
        : undef;
    my $inst_lib_paths = $self->{INST_ARCHLIB} ne $self->{INST_LIB}
        ? 'RUN)'.$perlflags.' "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"'
        : 'RUN)'.$perlflags.' "-I$(INST_LIB)"';
    # How do we run perl?
    foreach my $perl (qw(PERL FULLPERL ABSPERL)) {
        my $run  = $perl.'RUN';

        $self->{$run}  = qq{\$($perl)};
        $self->{$run} .= $lib_paths if $lib_paths;

        $self->{$perl.'RUNINST'} = '$('.$perl.$inst_lib_paths;
    }

    return 1;
}


=item init_platform

=item platform_constants

Add MM_Unix_VERSION.

=cut

sub init_platform {
    my($self) = shift;

    $self->{MM_Unix_VERSION} = $VERSION;
    $self->{PERL_MALLOC_DEF} = '-DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc '.
                               '-Dfree=Perl_mfree -Drealloc=Perl_realloc '.
                               '-Dcalloc=Perl_calloc';

}

sub platform_constants {
    my($self) = shift;
    my $make_frag = '';

    foreach my $macro (qw(MM_Unix_VERSION PERL_MALLOC_DEF))
    {
        next unless defined $self->{$macro};
        $make_frag .= "$macro = $self->{$macro}\n";
    }

    return $make_frag;
}


=item init_PERM

  $mm->init_PERM

Called by init_main.  Initializes PERL_*

=cut

sub init_PERM {
    my($self) = shift;

    $self->{PERM_DIR} = 755  unless defined $self->{PERM_DIR};
    $self->{PERM_RW}  = 644  unless defined $self->{PERM_RW};
    $self->{PERM_RWX} = 755  unless defined $self->{PERM_RWX};

    return 1;
}


=item init_xs

    $mm->init_xs

Sets up macros having to do with XS code.  Currently just INST_STATIC,
INST_DYNAMIC and INST_BOOT.

=cut

sub init_xs {
    my $self = shift;

    if ($self->has_link_code()) {
        $self->{INST_STATIC}  =
          $self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT)$(LIB_EXT)');
        $self->{INST_DYNAMIC} =
          $self->catfile('$(INST_ARCHAUTODIR)', '$(DLBASE).$(DLEXT)');
        $self->{INST_BOOT}    =
          $self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT).bs');
	if ($self->{XSMULTI}) {
	    my @exts = $self->_xs_list_basenames;
	    my (@statics, @dynamics, @boots);
	    for my $ext (@exts) {
		my ($v, $d, $f) = File::Spec->splitpath($ext);
		my @d = File::Spec->splitdir($d);
		shift @d if defined $d[0] and $d[0] eq 'lib';
		pop @d if $d[$#d] eq '';
		my $instdir = $self->catdir('$(INST_ARCHLIB)', 'auto', @d, $f);
		my $instfile = $self->catfile($instdir, $f);
		push @statics, "$instfile\$(LIB_EXT)";

                # Dynamic library names may need special handling.
                my $dynfile = $instfile;
                eval { require DynaLoader };
                if (defined &DynaLoader::mod2fname) {
                    $dynfile = $self->catfile($instdir, &DynaLoader::mod2fname([@d, $f]));
                }

		push @dynamics, "$dynfile.\$(DLEXT)";
		push @boots, "$instfile.bs";
	    }
	    $self->{INST_STATIC} = join ' ', @statics;
	    $self->{INST_DYNAMIC} = join ' ', @dynamics;
	    $self->{INST_BOOT} = join ' ', @boots;
	}
    } else {
        $self->{INST_STATIC}  = '';
        $self->{INST_DYNAMIC} = '';
        $self->{INST_BOOT}    = '';
    }
}

=item install (o)

Defines the install target.

=cut

sub install {
    my($self, %attribs) = @_;
    my(@m);

    push @m, q{
install :: pure_install doc_install
	$(NOECHO) $(NOOP)

install_perl :: pure_perl_install doc_perl_install
	$(NOECHO) $(NOOP)

install_site :: pure_site_install doc_site_install
	$(NOECHO) $(NOOP)

install_vendor :: pure_vendor_install doc_vendor_install
	$(NOECHO) $(NOOP)

pure_install :: pure_$(INSTALLDIRS)_install
	$(NOECHO) $(NOOP)

doc_install :: doc_$(INSTALLDIRS)_install
	$(NOECHO) $(NOOP)

pure__install : pure_site_install
	$(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site

doc__install : doc_site_install
	$(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site

pure_perl_install :: all
	$(NOECHO) umask 022; $(MOD_INSTALL) \
};

    push @m,
q{		"$(INST_LIB)" "$(DESTINSTALLPRIVLIB)" \
		"$(INST_ARCHLIB)" "$(DESTINSTALLARCHLIB)" \
		"$(INST_BIN)" "$(DESTINSTALLBIN)" \
		"$(INST_SCRIPT)" "$(DESTINSTALLSCRIPT)" \
		"$(INST_MAN1DIR)" "$(DESTINSTALLMAN1DIR)" \
		"$(INST_MAN3DIR)" "$(DESTINSTALLMAN3DIR)"
	$(NOECHO) $(WARN_IF_OLD_PACKLIST) \
		"}.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{"


pure_site_install :: all
	$(NOECHO) umask 02; $(MOD_INSTALL) \
};
    push @m,
q{		read "}.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{" \
		write "}.$self->catfile('$(DESTINSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{" \
} unless $self->{NO_PACKLIST};

    push @m,
q{		"$(INST_LIB)" "$(DESTINSTALLSITELIB)" \
		"$(INST_ARCHLIB)" "$(DESTINSTALLSITEARCH)" \
		"$(INST_BIN)" "$(DESTINSTALLSITEBIN)" \
		"$(INST_SCRIPT)" "$(DESTINSTALLSITESCRIPT)" \
		"$(INST_MAN1DIR)" "$(DESTINSTALLSITEMAN1DIR)" \
		"$(INST_MAN3DIR)" "$(DESTINSTALLSITEMAN3DIR)"
	$(NOECHO) $(WARN_IF_OLD_PACKLIST) \
		"}.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{"

pure_vendor_install :: all
	$(NOECHO) umask 022; $(MOD_INSTALL) \
};

    push @m,
q{		"$(INST_LIB)" "$(DESTINSTALLVENDORLIB)" \
		"$(INST_ARCHLIB)" "$(DESTINSTALLVENDORARCH)" \
		"$(INST_BIN)" "$(DESTINSTALLVENDORBIN)" \
		"$(INST_SCRIPT)" "$(DESTINSTALLVENDORSCRIPT)" \
		"$(INST_MAN1DIR)" "$(DESTINSTALLVENDORMAN1DIR)" \
		"$(INST_MAN3DIR)" "$(DESTINSTALLVENDORMAN3DIR)"

};

    push @m, q{
doc_perl_install :: all
	$(NOECHO) $(NOOP)

doc_site_install :: all
	$(NOECHO) $(NOOP)

doc_vendor_install :: all
	$(NOECHO) $(NOOP)

} if $self->{NO_PERLLOCAL};

    push @m, q{
doc_perl_install :: all

doc_site_install :: all
	$(NOECHO) $(ECHO) Appending installation info to "$(DESTINSTALLSITEARCH)/perllocal.pod"
	-$(NOECHO) umask 02; $(MKPATH) "$(DESTINSTALLSITEARCH)"
	-$(NOECHO) umask 02; $(DOC_INSTALL) \
		"Module" "$(NAME)" \
		"installed into" "$(INSTALLSITELIB)" \
		LINKTYPE "$(LINKTYPE)" \
		VERSION "$(VERSION)" \
		EXE_FILES "$(EXE_FILES)" \
		>> "}.$self->catfile('$(DESTINSTALLSITEARCH)','perllocal.pod').q{"

doc_vendor_install :: all

} unless $self->{NO_PERLLOCAL};

    push @m, q{
uninstall :: uninstall_from_$(INSTALLDIRS)dirs
	$(NOECHO) $(NOOP)

uninstall_from_perldirs ::

uninstall_from_sitedirs ::
	$(NOECHO) $(UNINSTALL) "}.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{"

uninstall_from_vendordirs ::
};

    join("",@m);
}

=item installbin (o)

Defines targets to make and to install EXE_FILES.

=cut

sub installbin {
    my($self) = shift;

    return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
    my @exefiles = sort @{$self->{EXE_FILES}};
    return "" unless @exefiles;

    @exefiles = map vmsify($_), @exefiles if $Is{VMS};

    my %fromto;
    for my $from (@exefiles) {
	my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));

	local($_) = $path; # for backwards compatibility
	my $to = $self->libscan($path);
	print "libscan($from) => '$to'\n" if ($Verbose >=2);

        $to = vmsify($to) if $Is{VMS};
	$fromto{$from} = $to;
    }
    my @to   = sort values %fromto;

    my @m;
    push(@m, qq{
EXE_FILES = @exefiles

pure_all :: @to
	\$(NOECHO) \$(NOOP)

realclean ::
});

    # realclean can get rather large.
    push @m, map "\t$_\n", $self->split_command('$(RM_F)', @to);
    push @m, "\n";

    # A target for each exe file.
    my @froms = sort keys %fromto;
    for my $from (@froms) {
        #                              1      2
        push @m, _sprintf562 <<'MAKE', $from, $fromto{$from};
%2$s : %1$s $(FIRST_MAKEFILE) $(INST_SCRIPT)$(DFSEP).exists $(INST_BIN)$(DFSEP).exists
	$(NOECHO) $(RM_F) %2$s
	$(CP) %1$s %2$s
	$(FIXIN) %2$s
	-$(NOECHO) $(CHMOD) $(PERM_RWX) %2$s

MAKE

    }

    join "", @m;
}

=item linkext (o)

Defines the linkext target which in turn defines the LINKTYPE.

=cut

# LINKTYPE => static or dynamic or ''
sub linkext {
    my($self, %attribs) = @_;
    my $linktype = $attribs{LINKTYPE};
    $linktype = $self->{LINKTYPE} unless defined $linktype;
    if (defined $linktype and $linktype eq '') {
        warn "Warning: LINKTYPE set to '', no longer necessary\n";
    }
    $linktype = '$(LINKTYPE)' unless defined $linktype;
    "
linkext :: $linktype
	\$(NOECHO) \$(NOOP)
";
}

=item lsdir

Takes as arguments a directory name and a regular expression. Returns
all entries in the directory that match the regular expression.

=cut

sub lsdir {
    #  $self
    my(undef, $dir, $regex) = @_;
    opendir(my $dh, defined($dir) ? $dir : ".")
        or return;
    my @ls = readdir $dh;
    closedir $dh;
    @ls = grep(/$regex/, @ls) if defined $regex;
    @ls;
}

=item macro (o)

Simple subroutine to insert the macros defined by the macro attribute
into the Makefile.

=cut

sub macro {
    my($self,%attribs) = @_;
    my @m;
    foreach my $key (sort keys %attribs) {
	my $val = $attribs{$key};
	push @m, "$key = $val\n";
    }
    join "", @m;
}

=item makeaperl (o)

Called by staticmake. Defines how to write the Makefile to produce a
static new perl.

By default the Makefile produced includes all the static extensions in
the perl library. (Purified versions of library files, e.g.,
DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)

=cut

sub makeaperl {
    my($self, %attribs) = @_;
    my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
	@attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
    s/^(.*)/"-I$1"/ for @{$perlinc || []};
    my(@m);
    push @m, "
# --- MakeMaker makeaperl section ---
MAP_TARGET    = $target
FULLPERL      = $self->{FULLPERL}
MAP_PERLINC   = @{$perlinc || []}
";
    return join '', @m if $self->{PARENT};

    my($dir) = join ":", @{$self->{DIR}};

    unless ($self->{MAKEAPERL}) {
	push @m, q{
$(MAP_TARGET) :: $(MAKE_APERL_FILE)
	$(MAKE) $(USEMAKEFILE) $(MAKE_APERL_FILE) $@

$(MAKE_APERL_FILE) : static $(FIRST_MAKEFILE) pm_to_blib
	$(NOECHO) $(ECHO) Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
	$(NOECHO) $(PERLRUNINST) \
		Makefile.PL DIR="}, $dir, q{" \
		MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
		MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};

	foreach (@ARGV){
		my $arg = $_; # avoid lvalue aliasing
		if ( $arg =~ /(^.*?=)(.*['\s].*)/ ) {
			$arg = $1 . $self->quote_literal($2);
		}
		push @m, " \\\n\t\t$arg";
	}
	push @m, "\n";

	return join '', @m;
    }

    my $cccmd = $self->const_cccmd($libperl);
    $cccmd =~ s/^CCCMD\s*=\s*//;
    $cccmd =~ s/\$\(INC\)/ "-I$self->{PERL_INC}" /;
    $cccmd .= " $Config{cccdlflags}"
	if ($Config{useshrplib} eq 'true');
    $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;

    # The front matter of the linkcommand...
    my $linkcmd = join ' ', "\$(CC)",
	    grep($_, @Config{qw(ldflags ccdlflags)});
    $linkcmd =~ s/\s+/ /g;
    $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;

    # Which *.a files could we make use of...
    my $staticlib21 = $self->_find_static_libs($searchdirs);
    # We trust that what has been handed in as argument, will be buildable
    $static = [] unless $static;
    @$staticlib21{@{$static}} = (1) x @{$static};

    $extra = [] unless $extra && ref $extra eq 'ARRAY';
    for (sort keys %$staticlib21) {
	next unless /\Q$self->{LIB_EXT}\E\z/;
	$_ = dirname($_) . "/extralibs.ld";
	push @$extra, $_;
    }

    s/^(.*)/"-I$1"/ for @{$perlinc || []};

    $target ||= "perl";
    $tmp    ||= ".";

# MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
# regenerate the Makefiles, MAP_STATIC and the dependencies for
# extralibs.all are computed correctly
    my @map_static = reverse sort keys %$staticlib21;
    push @m, "
MAP_LINKCMD   = $linkcmd
MAP_STATIC    = ", join(" \\\n\t", map { qq{"$_"} } @map_static), "
MAP_STATICDEP = ", join(' ', map { $self->quote_dep($_) } @map_static), "

MAP_PRELIBS   = $Config{perllibs} $Config{cryptlib}
";

    my $lperl;
    if (defined $libperl) {
	($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
    }
    unless ($libperl && -f $lperl) { # Ilya's code...
	my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/../..";
	$dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL};
	$libperl ||= "libperl$self->{LIB_EXT}";
	$libperl   = "$dir/$libperl";
	$lperl   ||= "libperl$self->{LIB_EXT}";
	$lperl     = "$dir/$lperl";

        if (! -f $libperl and ! -f $lperl) {
          # We did not find a static libperl. Maybe there is a shared one?
          if ($Is{SunOS}) {
            $lperl  = $libperl = "$dir/$Config{libperl}";
            # SUNOS ld does not take the full path to a shared library
            $libperl = '' if $Is{SunOS4};
          }
        }

	print <<EOF unless -f $lperl || defined($self->{PERL_SRC});
Warning: $libperl not found
If you're going to build a static perl binary, make sure perl is installed
otherwise ignore this warning
EOF
    }

    # SUNOS ld does not take the full path to a shared library
    my $llibperl = $libperl ? '$(MAP_LIBPERL)' : '-lperl';
    my $libperl_dep = $self->quote_dep($libperl);

    push @m, "
MAP_LIBPERL = $libperl
MAP_LIBPERLDEP = $libperl_dep
LLIBPERL    = $llibperl
";

    push @m, '
$(INST_ARCHAUTODIR)/extralibs.all : $(INST_ARCHAUTODIR)$(DFSEP).exists '.join(" \\\n\t", @$extra).'
	$(NOECHO) $(RM_F)  $@
	$(NOECHO) $(TOUCH) $@
';

    foreach my $catfile (@$extra){
	push @m, "\tcat $catfile >> \$\@\n";
    }

    my $ldfrom = $self->{XSMULTI} ? '' : '$(LDFROM)';
    #                             1     2                        3        4
    push @m, _sprintf562 <<'EOF', $tmp, $ldfrom, $self->xs_obj_opt('$@'), $makefilename;
$(MAP_TARGET) :: %1$s/perlmain$(OBJ_EXT) $(MAP_LIBPERLDEP) $(MAP_STATICDEP) $(INST_ARCHAUTODIR)/extralibs.all
	$(MAP_LINKCMD) %2$s $(OPTIMIZE) %1$s/perlmain$(OBJ_EXT) %3$s $(MAP_STATIC) "$(LLIBPERL)" `cat $(INST_ARCHAUTODIR)/extralibs.all` $(MAP_PRELIBS)
	$(NOECHO) $(ECHO) "To install the new '$(MAP_TARGET)' binary, call"
	$(NOECHO) $(ECHO) "    $(MAKE) $(USEMAKEFILE) %4$s inst_perl MAP_TARGET=$(MAP_TARGET)"
	$(NOECHO) $(ECHO) "    $(MAKE) $(USEMAKEFILE) %4$s map_clean"

%1$s/perlmain\$(OBJ_EXT): %1$s/perlmain.c
EOF
    push @m, "\t".$self->cd($tmp, qq[$cccmd "-I\$(PERL_INC)" perlmain.c])."\n";

    my $maybe_DynaLoader = $Config{usedl} ? 'q(DynaLoader)' : '';
    push @m, _sprintf562 <<'EOF', $tmp, $makefilename, $maybe_DynaLoader;

%1$s/perlmain.c: %2$s
	$(NOECHO) $(ECHO) Writing $@
	$(NOECHO) $(PERL) $(MAP_PERLINC) "-MExtUtils::Miniperl" \
		-e "writemain(grep(s#.*/auto/##s, @ARGV), %3$s)" $(MAP_STATIC) > $@t
	$(MV) $@t $@

EOF
    push @m, "\t", q{$(NOECHO) $(PERL) "$(INSTALLSCRIPT)/fixpmain"
} if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);


    push @m, q{
doc_inst_perl :
	$(NOECHO) $(ECHO) Appending installation info to "$(DESTINSTALLARCHLIB)/perllocal.pod"
	-$(NOECHO) $(MKPATH) "$(DESTINSTALLARCHLIB)"
	-$(NOECHO) $(DOC_INSTALL) \
		"Perl binary" "$(MAP_TARGET)" \
		MAP_STATIC "$(MAP_STATIC)" \
		MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
		MAP_LIBPERL "$(MAP_LIBPERL)" \
		>> "}.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{"

};

    push @m, q{
inst_perl : pure_inst_perl doc_inst_perl

pure_inst_perl : $(MAP_TARGET)
	}.$self->{CP}.q{ $(MAP_TARGET) "}.$self->catfile('$(DESTINSTALLBIN)','$(MAP_TARGET)').q{"

clean :: map_clean

map_clean :
	}.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
};

    join '', @m;
}

# utility method
sub _find_static_libs {
    my ($self, $searchdirs) = @_;
    # don't use File::Spec here because on Win32 F::F still uses "/"
    my $installed_version = join('/',
	'auto', $self->{FULLEXT}, "$self->{BASEEXT}$self->{LIB_EXT}"
    );
    my %staticlib21;
    require File::Find;
    File::Find::find(sub {
	if ($File::Find::name =~ m{/auto/share\z}) {
	    # in a subdir of auto/share, prune because e.g.
	    # Alien::pkgconfig uses File::ShareDir to put .a files
	    # there. do not want
	    $File::Find::prune = 1;
	    return;
	}

	return unless m/\Q$self->{LIB_EXT}\E$/;

	return unless -f 'extralibs.ld'; # this checks is a "proper" XS installation

        # Skip perl's libraries.
        return if m/^libperl/ or m/^perl\Q$self->{LIB_EXT}\E$/;

	# Skip purified versions of libraries
        # (e.g., DynaLoader_pure_p1_c0_032.a)
	return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";

	if( exists $self->{INCLUDE_EXT} ){
		my $found = 0;

		(my $xx = $File::Find::name) =~ s,.*?/auto/,,s;
		$xx =~ s,/?$_,,;
		$xx =~ s,/,::,g;

		# Throw away anything not explicitly marked for inclusion.
		# DynaLoader is implied.
		foreach my $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
			if( $xx eq $incl ){
				$found++;
				last;
			}
		}
		return unless $found;
	}
	elsif( exists $self->{EXCLUDE_EXT} ){
		(my $xx = $File::Find::name) =~ s,.*?/auto/,,s;
		$xx =~ s,/?$_,,;
		$xx =~ s,/,::,g;

		# Throw away anything explicitly marked for exclusion
		foreach my $excl (@{$self->{EXCLUDE_EXT}}){
			return if( $xx eq $excl );
		}
	}

	# don't include the installed version of this extension. I
	# leave this line here, although it is not necessary anymore:
	# I patched minimod.PL instead, so that Miniperl.pm won't
	# include duplicates

	# Once the patch to minimod.PL is in the distribution, I can
	# drop it
	return if $File::Find::name =~ m:\Q$installed_version\E\z:;
	return if !$self->xs_static_lib_is_xs($_);
	use Cwd 'cwd';
	$staticlib21{cwd() . "/" . $_}++;
    }, grep( -d $_, map { $self->catdir($_, 'auto') } @{$searchdirs || []}) );
    return \%staticlib21;
}

=item xs_static_lib_is_xs (o)

Called by a utility method of makeaperl. Checks whether a given file
is an XS library by seeing whether it defines any symbols starting
with C<boot_> (with an optional leading underscore - needed on MacOS).

=cut

sub xs_static_lib_is_xs {
    my ($self, $libfile) = @_;
    my $devnull = File::Spec->devnull;
    return `nm $libfile 2>$devnull` =~ /\b_?boot_/;
}

=item makefile (o)

Defines how to rewrite the Makefile.

=cut

sub makefile {
    my($self) = shift;
    my $m;
    # We do not know what target was originally specified so we
    # must force a manual rerun to be sure. But as it should only
    # happen very rarely it is not a significant problem.
    $m = '
$(OBJECT) : $(FIRST_MAKEFILE)

' if $self->{OBJECT};

    my $newer_than_target = $Is{VMS} ? '$(MMS$SOURCE_LIST)' : '$?';
    my $mpl_args = join " ", map qq["$_"], @ARGV;
    my $cross = '';
    if (defined $::Cross::platform) {
        # Inherited from win32/buildext.pl
        $cross = "-MCross=$::Cross::platform ";
    }
    $m .= sprintf <<'MAKE_FRAG', $newer_than_target, $cross, $mpl_args;
# We take a very conservative approach here, but it's worth it.
# We move Makefile to Makefile.old here to avoid gnu make looping.
$(FIRST_MAKEFILE) : Makefile.PL $(CONFIGDEP)
	$(NOECHO) $(ECHO) "Makefile out-of-date with respect to %s"
	$(NOECHO) $(ECHO) "Cleaning current config before rebuilding Makefile..."
	-$(NOECHO) $(RM_F) $(MAKEFILE_OLD)
	-$(NOECHO) $(MV)   $(FIRST_MAKEFILE) $(MAKEFILE_OLD)
	- $(MAKE) $(USEMAKEFILE) $(MAKEFILE_OLD) clean $(DEV_NULL)
	$(PERLRUN) %sMakefile.PL %s
	$(NOECHO) $(ECHO) "==> Your Makefile has been rebuilt. <=="
	$(NOECHO) $(ECHO) "==> Please rerun the $(MAKE) command.  <=="
	$(FALSE)

MAKE_FRAG

    return $m;
}


=item maybe_command

Returns true, if the argument is likely to be a command.

=cut

sub maybe_command {
    my($self,$file) = @_;
    return $file if -x $file && ! -d $file;
    return;
}


=item needs_linking (o)

Does this module need linking? Looks into subdirectory objects (see
also has_link_code())

=cut

sub needs_linking {
    my($self) = shift;

    my $caller = (caller(0))[3];
    confess("needs_linking called too early") if
      $caller =~ /^ExtUtils::MakeMaker::/;
    return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
    if ($self->has_link_code or $self->{MAKEAPERL}){
	$self->{NEEDS_LINKING} = 1;
	return 1;
    }
    foreach my $child (keys %{$self->{CHILDREN}}) {
	if ($self->{CHILDREN}->{$child}->needs_linking) {
	    $self->{NEEDS_LINKING} = 1;
	    return 1;
	}
    }
    return $self->{NEEDS_LINKING} = 0;
}


=item parse_abstract

parse a file and return what you think is the ABSTRACT

=cut

sub parse_abstract {
    my($self,$parsefile) = @_;
    my $result;

    local $/ = "\n";
    open(my $fh, '<', $parsefile) or die "Could not open '$parsefile': $!";
    binmode $fh;
    my $inpod = 0;
    my $pod_encoding;
    my $package = $self->{DISTNAME};
    $package =~ s/-/::/g;
    while (<$fh>) {
        $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
        next if !$inpod;
        s#\r*\n\z##; # handle CRLF input

        if ( /^=encoding\s*(.*)$/i ) {
            $pod_encoding = $1;
        }

        if ( /^($package(?:\.pm)? \s+ -+ \s+)(.*)/x ) {
          $result = $2;
          next;
        }
        next unless $result;

        if ( $result && ( /^\s*$/ || /^\=/ ) ) {
          last;
        }
        $result = join ' ', $result, $_;
    }
    close $fh;

    if ( $pod_encoding and !( "$]" < 5.008 or !$Config{useperlio} ) ) {
        # Have to wrap in an eval{} for when running under PERL_CORE
        # Encode isn't available during build phase and parsing
        # ABSTRACT isn't important there
        eval {
          require Encode;
          $result = Encode::decode($pod_encoding, $result);
        }
    }

    return $result;
}

=item parse_version

    my $version = MM->parse_version($file);

Parse a $file and return what $VERSION is set to by the first assignment.
It will return the string "undef" if it can't figure out what $VERSION
is. $VERSION should be for all to see, so C<our $VERSION> or plain $VERSION
are okay, but C<my $VERSION> is not.

C<package Foo VERSION> is also checked for.  The first version
declaration found is used, but this may change as it differs from how
Perl does it.

parse_version() will try to C<use version> before checking for
C<$VERSION> so the following will work.

    $VERSION = qv(1.2.3);

=cut

sub parse_version {
    my($self,$parsefile) = @_;
    my $result;

    local $/ = "\n";
    local $_;
    open(my $fh, '<', $parsefile) or die "Could not open '$parsefile': $!";
    my $inpod = 0;
    while (<$fh>) {
        $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
        next if $inpod || /^\s*#/;
        chop;
        next if /^\s*(if|unless|elsif)/;
        if ( m{^ \s* package \s+ \w[\w\:\']* \s+ (v?[0-9._]+) \s* (;|\{)  }x ) {
            no warnings;
            $result = $1;
        }
        elsif ( m{(?<!\\) ([\$*]) (([\w\:\']*) \bVERSION)\b .* (?<![<>=!])\=[^=]}x ) {
			$result = $self->get_version($parsefile, $1, $2);
        }
        else {
          next;
        }
        last if defined $result;
    }
    close $fh;

    if ( defined $result && $result !~ /^v?[\d_\.]+$/ ) {
      require version;
      my $normal = eval { version->new( $result ) };
      $result = $normal if defined $normal;
    }
    if ( defined $result ) {
      $result = "undef" unless $result =~ m!^v?[\d_\.]+$!
                        or eval { version->parse( $result ) };
    }
    $result = "undef" unless defined $result;
    return $result;
}

sub get_version {
    my ($self, $parsefile, $sigil, $name) = @_;
    my $line = $_; # from the while() loop in parse_version
    {
        package ExtUtils::MakeMaker::_version;
        undef *version; # in case of unexpected version() sub
        eval {
            require version;
            version::->import;
        };
        no strict;
        no warnings;
        local *{$name};
        $line = $1 if $line =~ m{^(.+)}s;
        eval($line); ## no critic
        return ${$name};
    }
}

=item pasthru (o)

Defines the string that is passed to recursive make calls in
subdirectories. The variables like C<PASTHRU_DEFINE> are used in each
level, and passed downwards on the command-line with e.g. the value of
that level's DEFINE. Example:

    # Level 0 has DEFINE = -Dfunky
    # This code will define level 0's PASTHRU=PASTHRU_DEFINE="$(DEFINE)
    #     $(PASTHRU_DEFINE)"
    # Level 0's $(CCCMD) will include macros $(DEFINE) and $(PASTHRU_DEFINE)
    # So will level 1's, so when level 1 compiles, it will get right values
    # And so ad infinitum

=cut

sub pasthru {
    my($self) = shift;
    my(@m);

    my(@pasthru);
    my($sep) = $Is{VMS} ? ',' : '';
    $sep .= "\\\n\t";

    foreach my $key (qw(LIB LIBPERL_A LINKTYPE OPTIMIZE LD
                     PREFIX INSTALL_BASE)
                 )
    {
        next unless defined $self->{$key};
	push @pasthru, "$key=\"\$($key)\"";
    }

    foreach my $key (qw(DEFINE INC)) {
        # default to the make var
        my $val = qq{\$($key)};
        # expand within perl if given since need to use quote_literal
        # since INC might include space-protecting ""!
        chomp($val = $self->{$key}) if defined $self->{$key};
        $val .= " \$(PASTHRU_$key)";
        my $quoted = $self->quote_literal($val);
        push @pasthru, qq{PASTHRU_$key=$quoted};
    }

    push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
    join "", @m;
}

=item perl_script

Takes one argument, a file name, and returns the file name, if the
argument is likely to be a perl script. On MM_Unix this is true for
any ordinary, readable file.

=cut

sub perl_script {
    my($self,$file) = @_;
    return $file if -r $file && -f _;
    return;
}

=item perldepend (o)

Defines the dependency from all *.h files that come with the perl
distribution.

=cut

sub perldepend {
    my($self) = shift;
    my(@m);

    my $make_config = $self->cd('$(PERL_SRC)', '$(MAKE) lib/Config.pm');

    push @m, sprintf <<'MAKE_FRAG', $make_config if $self->{PERL_SRC};
# Check for unpropogated config.sh changes. Should never happen.
# We do NOT just update config.h because that is not sufficient.
# An out of date config.h is not fatal but complains loudly!
$(PERL_INCDEP)/config.h: $(PERL_SRC)/config.sh
	-$(NOECHO) $(ECHO) "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; $(FALSE)

$(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
	$(NOECHO) $(ECHO) "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
	%s
MAKE_FRAG

    return join "", @m unless $self->needs_linking;

    if ($self->{OBJECT}) {
        # Need to add an object file dependency on the perl headers.
        # this is very important for XS modules in perl.git development.
        push @m, $self->_perl_header_files_fragment("/"); # Directory separator between $(PERL_INC)/header.h
    }

    push @m, join(" ", sort values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};

    return join "\n", @m;
}


=item pm_to_blib

Defines target that copies all files in the hash PM to their
destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>

=cut

sub pm_to_blib {
    my $self = shift;
    my($autodir) = $self->catdir('$(INST_LIB)','auto');
    my $r = q{
pm_to_blib : $(FIRST_MAKEFILE) $(TO_INST_PM)
};

    # VMS will swallow '' and PM_FILTER is often empty.  So use q[]
    my $pm_to_blib = $self->oneliner(<<CODE, ['-MExtUtils::Install']);
pm_to_blib({\@ARGV}, '$autodir', q[\$(PM_FILTER)], '\$(PERM_DIR)')
CODE

    my @cmds = $self->split_command($pm_to_blib,
                  map { ($self->quote_literal($_) => $self->quote_literal($self->{PM}->{$_})) } sort keys %{$self->{PM}});

    $r .= join '', map { "\t\$(NOECHO) $_\n" } @cmds;
    $r .= qq{\t\$(NOECHO) \$(TOUCH) pm_to_blib\n};

    return $r;
}

# transform dot-separated version string into comma-separated quadruple
# examples:  '1.2.3.4.5' => '1,2,3,4'
#            '1.2.3'     => '1,2,3,0'
sub _ppd_version {
    my ($self, $string) = @_;
    return join ',', ((split /\./, $string), (0) x 4)[0..3];
}

=item ppd

Defines target that creates a PPD (Perl Package Description) file
for a binary distribution.

=cut

sub ppd {
    my($self) = @_;

    my $abstract = $self->{ABSTRACT} || '';
    $abstract =~ s/\n/\\n/sg;
    $abstract =~ s/</&lt;/g;
    $abstract =~ s/>/&gt;/g;

    my $author = join(', ',@{ ref $self->{AUTHOR} eq 'ARRAY' ? $self->{AUTHOR} : [ $self->{AUTHOR} || '']});
    $author =~ s/</&lt;/g;
    $author =~ s/>/&gt;/g;

    my $ppd_file = "$self->{DISTNAME}.ppd";

    my @ppd_chunks = qq(<SOFTPKG NAME="$self->{DISTNAME}" VERSION="$self->{VERSION}">\n);

    push @ppd_chunks, sprintf <<'PPD_HTML', $abstract, $author;
    <ABSTRACT>%s</ABSTRACT>
    <AUTHOR>%s</AUTHOR>
PPD_HTML

    push @ppd_chunks, "    <IMPLEMENTATION>\n";
    if ( $self->{MIN_PERL_VERSION} ) {
        my $min_perl_version = $self->_ppd_version($self->{MIN_PERL_VERSION});
        push @ppd_chunks, sprintf <<'PPD_PERLVERS', $min_perl_version;
        <PERLCORE VERSION="%s" />
PPD_PERLVERS

    }

    # Don't add "perl" to requires.  perl dependencies are
    # handles by ARCHITECTURE.
    my %prereqs = %{$self->{PREREQ_PM}};
    delete $prereqs{perl};

    # Build up REQUIRE
    foreach my $prereq (sort keys %prereqs) {
        my $name = $prereq;
        $name .= '::' unless $name =~ /::/;
        my $version = $prereqs{$prereq};

        my %attrs = ( NAME => $name );
        $attrs{VERSION} = $version if $version;
        my $attrs = join " ", map { qq[$_="$attrs{$_}"] } sort keys %attrs;
        push @ppd_chunks, qq(        <REQUIRE $attrs />\n);
    }

    my $archname = $Config{archname};

    # archname did not change from 5.6 to 5.8, but those versions may
    # not be not binary compatible so now we append the part of the
    # version that changes when binary compatibility may change
    if ("$]" >= 5.008) {
        $archname .= "-$Config{api_revision}.$Config{api_version}";
    }
    push @ppd_chunks, sprintf <<'PPD_OUT', $archname;
        <ARCHITECTURE NAME="%s" />
PPD_OUT

    if ($self->{PPM_INSTALL_SCRIPT}) {
        if ($self->{PPM_INSTALL_EXEC}) {
            push @ppd_chunks, sprintf qq{        <INSTALL EXEC="%s">%s</INSTALL>\n},
                  $self->{PPM_INSTALL_EXEC}, $self->{PPM_INSTALL_SCRIPT};
        }
        else {
            push @ppd_chunks, sprintf qq{        <INSTALL>%s</INSTALL>\n},
                  $self->{PPM_INSTALL_SCRIPT};
        }
    }

    if ($self->{PPM_UNINSTALL_SCRIPT}) {
        if ($self->{PPM_UNINSTALL_EXEC}) {
            push @ppd_chunks, sprintf qq{        <UNINSTALL EXEC="%s">%s</UNINSTALL>\n},
                  $self->{PPM_UNINSTALL_EXEC}, $self->{PPM_UNINSTALL_SCRIPT};
        }
        else {
            push @ppd_chunks, sprintf qq{        <UNINSTALL>%s</UNINSTALL>\n},
                  $self->{PPM_UNINSTALL_SCRIPT};
        }
    }

    my ($bin_location) = $self->{BINARY_LOCATION} || '';
    $bin_location =~ s/\\/\\\\/g;

    push @ppd_chunks, sprintf <<'PPD_XML', $bin_location;
        <CODEBASE HREF="%s" />
    </IMPLEMENTATION>
</SOFTPKG>
PPD_XML

    my @ppd_cmds = $self->stashmeta(join('', @ppd_chunks), $ppd_file);

    return sprintf <<'PPD_OUT', join "\n\t", @ppd_cmds;
# Creates a PPD (Perl Package Description) for a binary distribution.
ppd :
	%s
PPD_OUT

}

=item prefixify

  $MM->prefixify($var, $prefix, $new_prefix, $default);

Using either $MM->{uc $var} || $Config{lc $var}, it will attempt to
replace it's $prefix with a $new_prefix.

Should the $prefix fail to match I<AND> a PREFIX was given as an
argument to WriteMakefile() it will set it to the $new_prefix +
$default.  This is for systems whose file layouts don't neatly fit into
our ideas of prefixes.

This is for heuristics which attempt to create directory structures
that mirror those of the installed perl.

For example:

    $MM->prefixify('installman1dir', '/usr', '/home/foo', 'man/man1');

this will attempt to remove '/usr' from the front of the
$MM->{INSTALLMAN1DIR} path (initializing it to $Config{installman1dir}
if necessary) and replace it with '/home/foo'.  If this fails it will
simply use '/home/foo/man/man1'.

=cut

sub prefixify {
    my($self,$var,$sprefix,$rprefix,$default) = @_;

    my $path = $self->{uc $var} ||
               $Config_Override{lc $var} || $Config{lc $var} || '';

    $rprefix .= '/' if $sprefix =~ m|/$|;

    warn "  prefixify $var => $path\n" if $Verbose >= 2;
    warn "    from $sprefix to $rprefix\n" if $Verbose >= 2;

    if( $self->{ARGS}{PREFIX} &&
        $path !~ s{^\Q$sprefix\E\b}{$rprefix}s )
    {

        warn "    cannot prefix, using default.\n" if $Verbose >= 2;
        warn "    no default!\n" if !$default && $Verbose >= 2;

        $path = $self->catdir($rprefix, $default) if $default;
    }

    print "    now $path\n" if $Verbose >= 2;
    return $self->{uc $var} = $path;
}


=item processPL (o)

Defines targets to run *.PL files.

=cut

sub processPL {
    my $self = shift;
    my $pl_files = $self->{PL_FILES};

    return "" unless $pl_files;

    my $m = '';
    foreach my $plfile (sort keys %$pl_files) {
        my $targets = $pl_files->{$plfile};
        my $list =
            ref($targets) eq 'HASH'  ? [ sort keys %$targets ] :
            ref($targets) eq 'ARRAY' ? $pl_files->{$plfile}   :
            [$pl_files->{$plfile}];

        foreach my $target (@$list) {
            if( $Is{VMS} ) {
                $plfile = vmsify($self->eliminate_macros($plfile));
                $target = vmsify($self->eliminate_macros($target));
            }

            # Normally a .PL file runs AFTER pm_to_blib so it can have
            # blib in its @INC and load the just built modules.  BUT if
            # the generated module is something in $(TO_INST_PM) which
            # pm_to_blib depends on then it can't depend on pm_to_blib
            # else we have a dependency loop.
            my $pm_dep;
            my $perlrun;
            if( defined $self->{PM}{$target} ) {
                $pm_dep  = '';
                $perlrun = 'PERLRUN';
            }
            else {
                $pm_dep  = 'pm_to_blib';
                $perlrun = 'PERLRUNINST';
            }

            my $extra_inputs = '';
            if( ref($targets) eq 'HASH' ) {
                my $inputs = ref($targets->{$target})
                    ? $targets->{$target}
                    : [$targets->{$target}];

                for my $input (@$inputs) {
                    if( $Is{VMS} ) {
                        $input = vmsify($self->eliminate_macros($input));
                    }
                    $extra_inputs .= ' '.$input;
                }
            }

            $m .= <<MAKE_FRAG;

pure_all :: $target
	\$(NOECHO) \$(NOOP)

$target :: $plfile $pm_dep $extra_inputs
	\$($perlrun) $plfile $target $extra_inputs
MAKE_FRAG

        }
    }

    return $m;
}

=item specify_shell

Specify SHELL if needed - not done on Unix.

=cut

sub specify_shell {
  return '';
}

=item quote_paren

Backslashes parentheses C<()> in command line arguments.
Doesn't handle recursive Makefile C<$(...)> constructs,
but handles simple ones.

=cut

sub quote_paren {
    my $arg = shift;
    $arg =~ s{\$\((.+?)\)}{\$\\\\($1\\\\)}g;	# protect $(...)
    $arg =~ s{(?<!\\)([()])}{\\$1}g;		# quote unprotected
    $arg =~ s{\$\\\\\((.+?)\\\\\)}{\$($1)}g;	# unprotect $(...)
    return $arg;
}

=item replace_manpage_separator

  my $man_name = $MM->replace_manpage_separator($file_path);

Takes the name of a package, which may be a nested package, in the
form 'Foo/Bar.pm' and replaces the slash with C<::> or something else
safe for a man page file name.  Returns the replacement.

=cut

sub replace_manpage_separator {
    my($self,$man) = @_;

    $man =~ s,/+,::,g;
    return $man;
}


=item cd

=cut

sub cd {
    my($self, $dir, @cmds) = @_;

    # No leading tab and no trailing newline makes for easier embedding
    my $make_frag = join "\n\t", map { "cd $dir && $_" } @cmds;

    return $make_frag;
}

=item oneliner

=cut

sub oneliner {
    my($self, $cmd, $switches) = @_;
    $switches = [] unless defined $switches;

    # Strip leading and trailing newlines
    $cmd =~ s{^\n+}{};
    $cmd =~ s{\n+$}{};

    my @cmds = split /\n/, $cmd;
    $cmd = join " \n\t  -e ", map $self->quote_literal($_), @cmds;
    $cmd = $self->escape_newlines($cmd);

    $switches = join ' ', @$switches;

    return qq{\$(ABSPERLRUN) $switches -e $cmd --};
}


=item quote_literal

Quotes macro literal value suitable for being used on a command line so
that when expanded by make, will be received by command as given to
this method:

  my $quoted = $mm->quote_literal(q{it isn't});
  # returns:
  #   'it isn'\''t'
  print MAKEFILE "target:\n\techo $quoted\n";
  # when run "make target", will output:
  #   it isn't

=cut

sub quote_literal {
    my($self, $text, $opts) = @_;
    $opts->{allow_variables} = 1 unless defined $opts->{allow_variables};

    # Quote single quotes
    $text =~ s{'}{'\\''}g;

    $text = $opts->{allow_variables}
      ? $self->escape_dollarsigns($text) : $self->escape_all_dollarsigns($text);

    return "'$text'";
}


=item escape_newlines

=cut

sub escape_newlines {
    my($self, $text) = @_;

    $text =~ s{\n}{\\\n}g;

    return $text;
}


=item max_exec_len

Using L<POSIX>::ARG_MAX.  Otherwise falling back to 4096.

=cut

sub max_exec_len {
    my $self = shift;

    if (!defined $self->{_MAX_EXEC_LEN}) {
        if (my $arg_max = eval { require POSIX;  &POSIX::ARG_MAX }) {
            $self->{_MAX_EXEC_LEN} = $arg_max;
        }
        else {      # POSIX minimum exec size
            $self->{_MAX_EXEC_LEN} = 4096;
        }
    }

    return $self->{_MAX_EXEC_LEN};
}


=item static (o)

Defines the static target.

=cut

sub static {
# --- Static Loading Sections ---

    my($self) = shift;
    '
## $(INST_PM) has been moved to the all: target.
## It remains here for awhile to allow for old usage: "make static"
static :: $(FIRST_MAKEFILE) $(INST_STATIC)
	$(NOECHO) $(NOOP)
';
}

sub static_lib {
    my($self) = @_;
    return '' unless $self->has_link_code;
    my(@m);
    my @libs;
    if ($self->{XSMULTI}) {
	for my $ext ($self->_xs_list_basenames) {
	    my ($v, $d, $f) = File::Spec->splitpath($ext);
	    my @d = File::Spec->splitdir($d);
	    shift @d if $d[0] eq 'lib';
	    my $instdir = $self->catdir('$(INST_ARCHLIB)', 'auto', @d, $f);
	    my $instfile = $self->catfile($instdir, "$f\$(LIB_EXT)");
	    my $objfile = "$ext\$(OBJ_EXT)";
	    push @libs, [ $objfile, $instfile, $instdir ];
	}
    } else {
	@libs = ([ qw($(OBJECT) $(INST_STATIC) $(INST_ARCHAUTODIR)) ]);
    }
    push @m, map { $self->xs_make_static_lib(@$_); } @libs;
    join "\n", @m;
}

=item xs_make_static_lib

Defines the recipes for the C<static_lib> section.

=cut

sub xs_make_static_lib {
    my ($self, $from, $to, $todir) = @_;
    my @m = sprintf '%s: %s $(MYEXTLIB) %s$(DFSEP).exists'."\n", $to, $from, $todir;
    push @m, "\t\$(RM_F) \"\$\@\"\n";
    push @m, $self->static_lib_fixtures;
    push @m, $self->static_lib_pure_cmd($from);
    push @m, "\t\$(CHMOD) \$(PERM_RWX) \$\@\n";
    push @m, $self->static_lib_closures($todir);
    join '', @m;
}

=item static_lib_closures

Records C<$(EXTRALIBS)> in F<extralibs.ld> and F<$(PERL_SRC)/ext.libs>.

=cut

sub static_lib_closures {
    my ($self, $todir) = @_;
    my @m = sprintf <<'MAKE_FRAG', $todir;
	$(NOECHO) $(ECHO) "$(EXTRALIBS)" > %s$(DFSEP)extralibs.ld
MAKE_FRAG
    # Old mechanism - still available:
    push @m, <<'MAKE_FRAG' if $self->{PERL_SRC} && $self->{EXTRALIBS};
	$(NOECHO) $(ECHO) "$(EXTRALIBS)" >> $(PERL_SRC)$(DFSEP)ext.libs
MAKE_FRAG
    @m;
}

=item static_lib_fixtures

Handles copying C<$(MYEXTLIB)> as starter for final static library that
then gets added to.

=cut

sub static_lib_fixtures {
    my ($self) = @_;
    # If this extension has its own library (eg SDBM_File)
    # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
    return unless $self->{MYEXTLIB};
    "\t\$(CP) \$(MYEXTLIB) \"\$\@\"\n";
}

=item static_lib_pure_cmd

Defines how to run the archive utility.

=cut

sub static_lib_pure_cmd {
    my ($self, $from) = @_;
    my $ar;
    if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
        # Prefer the absolute pathed ar if available so that PATH
        # doesn't confuse us.  Perl itself is built with the full_ar.
        $ar = 'FULL_AR';
    } else {
        $ar = 'AR';
    }
    sprintf <<'MAKE_FRAG', $ar, $from;
	$(%s) $(AR_STATIC_ARGS) "$@" %s
	$(RANLIB) "$@"
MAKE_FRAG
}

=item staticmake (o)

Calls makeaperl.

=cut

sub staticmake {
    my($self, %attribs) = @_;
    my(@static);

    my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});

    # And as it's not yet built, we add the current extension
    # but only if it has some C code (or XS code, which implies C code)
    if (@{$self->{C}}) {
	@static = $self->catfile($self->{INST_ARCHLIB},
				 "auto",
				 $self->{FULLEXT},
				 "$self->{BASEEXT}$self->{LIB_EXT}"
				);
    }

    # Either we determine now, which libraries we will produce in the
    # subdirectories or we do it at runtime of the make.

    # We could ask all subdir objects, but I cannot imagine, why it
    # would be necessary.

    # Instead we determine all libraries for the new perl at
    # runtime.
    my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});

    $self->makeaperl(MAKE	=> $self->{MAKEFILE},
		     DIRS	=> \@searchdirs,
		     STAT	=> \@static,
		     INCL	=> \@perlinc,
		     TARGET	=> $self->{MAP_TARGET},
		     TMP	=> "",
		     LIBPERL	=> $self->{LIBPERL_A}
		    );
}

=item subdir_x (o)

Helper subroutine for subdirs

=cut

sub subdir_x {
    my($self, $subdir) = @_;

    my $subdir_cmd = $self->cd($subdir,
      '$(MAKE) $(USEMAKEFILE) $(FIRST_MAKEFILE) all $(PASTHRU)'
    );
    return sprintf <<'EOT', $subdir_cmd;

subdirs ::
	$(NOECHO) %s
EOT

}

=item subdirs (o)

Defines targets to process subdirectories.

=cut

sub subdirs {
# --- Sub-directory Sections ---
    my($self) = shift;
    my(@m);
    # This method provides a mechanism to automatically deal with
    # subdirectories containing further Makefile.PL scripts.
    # It calls the subdir_x() method for each subdirectory.
    foreach my $dir (@{$self->{DIR}}){
	push @m, $self->subdir_x($dir);
####	print "Including $dir subdirectory\n";
    }
    if (@m){
	unshift @m, <<'EOF';

# The default clean, realclean and test targets in this Makefile
# have automatically been given entries for each subdir.

EOF
    } else {
	push(@m, "\n# none")
    }
    join('',@m);
}

=item test (o)

Defines the test targets.

=cut

sub test {
    my($self, %attribs) = @_;
    my $tests = $attribs{TESTS} || '';
    if (!$tests && -d 't' && defined $attribs{RECURSIVE_TEST_FILES}) {
        $tests = $self->find_tests_recursive;
    }
    elsif (!$tests && -d 't') {
        $tests = $self->find_tests;
    }
    # have to do this because nmake is broken
    $tests =~ s!/!\\!g if $self->is_make_type('nmake');
    # note: 'test.pl' name is also hardcoded in init_dirscan()
    my @m;
    my $default_testtype = $Config{usedl} ? 'dynamic' : 'static';
    push @m, <<EOF;
TEST_VERBOSE=0
TEST_TYPE=test_\$(LINKTYPE)
TEST_FILE = test.pl
TEST_FILES = $tests
TESTDB_SW = -d

testdb :: testdb_\$(LINKTYPE)
	\$(NOECHO) \$(NOOP)

test :: \$(TEST_TYPE)
	\$(NOECHO) \$(NOOP)

# Occasionally we may face this degenerate target:
test_ : test_$default_testtype
	\$(NOECHO) \$(NOOP)

EOF

    for my $linktype (qw(dynamic static)) {
        my $directdeps = join ' ', grep !$self->{SKIPHASH}{$_}, $linktype, "pure_all"; # no depend on a linktype if SKIPped
        push @m, "subdirs-test_$linktype :: $directdeps\n";
        foreach my $dir (@{ $self->{DIR} }) {
            my $test = $self->cd($dir, "\$(MAKE) test_$linktype \$(PASTHRU)");
            push @m, "\t\$(NOECHO) $test\n";
        }
        push @m, "\n";
        if ($tests or -f "test.pl") {
            for my $testspec ([ '', '' ], [ 'db', ' $(TESTDB_SW)' ]) {
                my ($db, $switch) = @$testspec;
                my ($command, $deps);
                # if testdb, build all but don't test all
                $deps = $db eq 'db' ? $directdeps : "subdirs-test_$linktype";
                if ($linktype eq 'static' and $self->needs_linking) {
                    my $target = File::Spec->rel2abs('$(MAP_TARGET)');
                    $command = qq{"$target" \$(MAP_PERLINC)};
                    $deps .= ' $(MAP_TARGET)';
                } else {
                    $command = '$(FULLPERLRUN)' . $switch;
                }
                push @m, "test${db}_$linktype :: $deps\n";
                if ($db eq 'db') {
                    push @m, $self->test_via_script($command, '$(TEST_FILE)')
                } else {
                    push @m, $self->test_via_script($command, '$(TEST_FILE)')
                        if -f "test.pl";
                    push @m, $self->test_via_harness($command, '$(TEST_FILES)')
                        if $tests;
                }
                push @m, "\n";
            }
        } else {
            push @m, _sprintf562 <<'EOF', $linktype;
testdb_%1$s test_%1$s :: subdirs-test_%1$s
	$(NOECHO) $(ECHO) 'No tests defined for $(NAME) extension.'

EOF
        }
    }

    join "", @m;
}

=item test_via_harness (override)

For some reason which I forget, Unix machines like to have
PERL_DL_NONLAZY set for tests.

=cut

sub test_via_harness {
    my($self, $perl, $tests) = @_;
    return $self->SUPER::test_via_harness("PERL_DL_NONLAZY=1 $perl", $tests);
}

=item test_via_script (override)

Again, the PERL_DL_NONLAZY thing.

=cut

sub test_via_script {
    my($self, $perl, $script) = @_;
    return $self->SUPER::test_via_script("PERL_DL_NONLAZY=1 $perl", $script);
}


=item tool_xsubpp (o)

Determines typemaps, xsubpp version, prototype behaviour.

=cut

sub tool_xsubpp {
    my($self) = shift;
    return "" unless $self->needs_linking;

    my $xsdir;
    my @xsubpp_dirs = @INC;

    # Make sure we pick up the new xsubpp if we're building perl.
    unshift @xsubpp_dirs, $self->{PERL_LIB} if $self->{PERL_CORE};

    my $foundxsubpp = 0;
    foreach my $dir (@xsubpp_dirs) {
        $xsdir = $self->catdir($dir, 'ExtUtils');
        if( -r $self->catfile($xsdir, "xsubpp") ) {
            $foundxsubpp = 1;
            last;
        }
    }
    die "ExtUtils::MM_Unix::tool_xsubpp : Can't find xsubpp" if !$foundxsubpp;

    my $tmdir   = $self->catdir($self->{PERL_LIB},"ExtUtils");
    my(@tmdeps) = $self->catfile($tmdir,'typemap');
    if( $self->{TYPEMAPS} ){
        foreach my $typemap (@{$self->{TYPEMAPS}}){
            if( ! -f  $typemap ) {
                warn "Typemap $typemap not found.\n";
            }
            else {
                $typemap = vmsify($typemap) if $Is{VMS};
                push(@tmdeps, $typemap);
            }
        }
    }
    push(@tmdeps, "typemap") if -f "typemap";
    # absolutised because with deep-located typemaps, eg "lib/XS/typemap",
    # if xsubpp is called from top level with
    #     $(XSUBPP) ... -typemap "lib/XS/typemap" "lib/XS/Test.xs"
    # it says:
    #     Can't find lib/XS/type map in (fulldir)/lib/XS
    # because ExtUtils::ParseXS::process_file chdir's to .xs file's
    # location. This is the only way to get all specified typemaps used,
    # wherever located.
    my @tmargs = map { '-typemap '.$self->quote_literal(File::Spec->rel2abs($_)) } @tmdeps;
    $_ = $self->quote_dep($_) for @tmdeps;
    if( exists $self->{XSOPT} ){
        unshift( @tmargs, $self->{XSOPT} );
    }

    if ($Is{VMS}                          &&
        $Config{'ldflags'}               &&
        $Config{'ldflags'} =~ m!/Debug!i &&
        (!exists($self->{XSOPT}) || $self->{XSOPT} !~ /linenumbers/)
       )
    {
        unshift(@tmargs,'-nolinenumbers');
    }


    $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
    my $xsdirdep = $self->quote_dep($xsdir);
    # -dep for use when dependency not command

    return qq{
XSUBPPDIR = $xsdir
XSUBPP = "\$(XSUBPPDIR)\$(DFSEP)xsubpp"
XSUBPPRUN = \$(PERLRUN) \$(XSUBPP)
XSPROTOARG = $self->{XSPROTOARG}
XSUBPPDEPS = @tmdeps $xsdirdep\$(DFSEP)xsubpp
XSUBPPARGS = @tmargs
XSUBPP_EXTRA_ARGS =
};
}


=item all_target

Build man pages, too

=cut

sub all_target {
    my $self = shift;

    return <<'MAKE_EXT';
all :: pure_all manifypods
	$(NOECHO) $(NOOP)
MAKE_EXT
}

=item top_targets (o)

Defines the targets all, subdirs, config, and O_FILES

=cut

sub top_targets {
# --- Target Sections ---

    my($self) = shift;
    my(@m);

    push @m, $self->all_target, "\n" unless $self->{SKIPHASH}{'all'};

    push @m, sprintf <<'EOF';
pure_all :: config pm_to_blib subdirs linkext
	$(NOECHO) $(NOOP)

subdirs :: $(MYEXTLIB)
	$(NOECHO) $(NOOP)

config :: $(FIRST_MAKEFILE) blibdirs
	$(NOECHO) $(NOOP)
EOF

    push @m, '
$(O_FILES) : $(H_FILES)
' if @{$self->{O_FILES} || []} && @{$self->{H} || []};

    push @m, q{
help :
	perldoc ExtUtils::MakeMaker
};

    join('',@m);
}

=item writedoc

Obsolete, deprecated method. Not used since Version 5.21.

=cut

sub writedoc {
# --- perllocal.pod section ---
    my($self,$what,$name,@attribs)=@_;
    my $time = gmtime($ENV{SOURCE_DATE_EPOCH} || time);
    print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
    print join "\n\n=item *\n\n", map("C<$_>",@attribs);
    print "\n\n=back\n\n";
}

=item xs_c (o)

Defines the suffix rules to compile XS files to C.

=cut

sub xs_c {
    my($self) = shift;
    return '' unless $self->needs_linking();
    '
.xs.c:
	$(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $*.xs > $*.xsc
	$(MV) $*.xsc $*.c
';
}

=item xs_cpp (o)

Defines the suffix rules to compile XS files to C++.

=cut

sub xs_cpp {
    my($self) = shift;
    return '' unless $self->needs_linking();
    '
.xs.cpp:
	$(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc
	$(MV) $*.xsc $*.cpp
';
}

=item xs_o (o)

Defines suffix rules to go from XS to object files directly. This was
originally only intended for broken make implementations, but is now
necessary for per-XS file under C<XSMULTI>, since each XS file might
have an individual C<$(VERSION)>.

=cut

sub xs_o {
    my ($self) = @_;
    return '' unless $self->needs_linking();
    my $m_o = $self->{XSMULTI} ? $self->xs_obj_opt('$*$(OBJ_EXT)') : '';
    my $dbgout = $self->dbgoutflag;
    $dbgout = $dbgout ? "$dbgout " : '';
    my $frag = '';
    # dmake makes noise about ambiguous rule
    $frag .= sprintf <<'EOF', $dbgout, $m_o unless $self->is_make_type('dmake');
.xs$(OBJ_EXT) :
	$(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc
	$(MV) $*.xsc $*.c
	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) %s$*.c %s
EOF
    if ($self->{XSMULTI}) {
	for my $ext ($self->_xs_list_basenames) {
	    my $pmfile = "$ext.pm";
	    croak "$ext.xs has no matching $pmfile: $!" unless -f $pmfile;
	    my $version = $self->parse_version($pmfile);
	    my $cccmd = $self->{CONST_CCCMD};
	    $cccmd =~ s/^\s*CCCMD\s*=\s*//;
	    $cccmd =~ s/\$\(DEFINE_VERSION\)/-DVERSION=\\"$version\\"/;
	    $cccmd =~ s/\$\(XS_DEFINE_VERSION\)/-DXS_VERSION=\\"$version\\"/;
            $self->_xsbuild_replace_macro($cccmd, 'xs', $ext, 'INC');
            my $define = '$(DEFINE)';
            $self->_xsbuild_replace_macro($define, 'xs', $ext, 'DEFINE');
            #                             1     2       3     4        5
            $frag .= _sprintf562 <<'EOF', $ext, $cccmd, $m_o, $define, $dbgout;

%1$s$(OBJ_EXT): %1$s.xs
	$(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc
	$(MV) $*.xsc $*.c
	%2$s $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) %4$s %5$s$*.c %3$s
EOF
	}
    }
    $frag =~ s/"-I(\$\(PERL_INC\))"/-iwithsysroot "$1"/sg if $Is{ApplCor};
    $frag;
}

# param gets modified
sub _xsbuild_replace_macro {
    my ($self, undef, $xstype, $ext, $varname) = @_;
    my $value = $self->_xsbuild_value($xstype, $ext, $varname);
    return unless defined $value;
    $_[1] =~ s/\$\($varname\)/$value/;
}

sub _xsbuild_value {
    my ($self, $xstype, $ext, $varname) = @_;
    return $self->{XSBUILD}{$xstype}{$ext}{$varname}
        if $self->{XSBUILD}{$xstype}{$ext}{$varname};
    return $self->{XSBUILD}{$xstype}{all}{$varname}
        if $self->{XSBUILD}{$xstype}{all}{$varname};
    ();
}

1;

=back

=head1 SEE ALSO

L<ExtUtils::MakeMaker>

=cut

__END__
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Caml1999I030    T  `{  ]&Stdlib%raise3@#exnG@@ @!a @@ @&%raiseAA @@@*stdlib.mli^BB^Bg@@@@-raise_notrace4@@@ @!a @@ @.%raise_notraceAA@@@aa@@3A@+invalid_arg5@&stringO@@ @!a @@ @@-f.f<@@HB@(failwith6@@@ @!a @@ @@@iAi@@[C@ $Exit7    V@@@A&_none_@@ A@fDB@ -Match_failure8    @6@@ @#intA@@ @@@ @@ @@@A=ocaml.warn_on_literal_patternmqnq@@qqrq@@EB@ .Assert_failure9    1@\@@ @"&@@ @!+@@ @ @ @#@@AB=ocaml.warn_on_literal_patternw		w		@@w		w		@@FB@ 0Invalid_argument:    U@}@@ @$@@AY=ocaml.warn_on_literal_pattern}

}

@@}

}

@@GB@ 'Failure;    l@@@ @%@@Ap=ocaml.warn_on_literal_pattern E E@@ E E@@HB@ )Not_found<    @@@A@IB@ -Out_of_memory=    @@@A@JB@ .Stack_overflow>    @@@A@KB@ )Sys_error?    @@@ @&@@A=ocaml.warn_on_literal_pattern ^ ^@@ ^ ^@@
LB@ +End_of_file@    @@@A@MB@ 0Division_by_zeroA    @@@A@NB@ .Sys_blocked_ioB    @@@A@OB@ :Undefined_recursive_moduleC    @@@ @)@@ @(@@ @'@ @*@@Aՠ=ocaml.warn_on_literal_pattern$ r% r@@( r) r@@CPB@!=D@!a @+@$boolE@@ @,@ @-@ @.&%equalBAD@@@@D yE y@@_Q@"<>E@!a @/@@@ @0@ @1@ @2)%notequalBA^@@@@^ _ @@yR@!<F@!a @3@6@@ @4@ @5@ @6)%lessthanBAx@@@@x YYy Y@@S@!>G@!a @7@P@@ @8@ @9@ @:,%greaterthanBA@@@@  %@@T@"<=H@!a @;@j@@ @<@ @=@ @>*%lessequalBA@@@@  @@U@">=I@!a @?@@@ @@@ @A@ @B-%greaterequalBAƠ@@@@ .. .b@@V@'compareJ@!a @C@y@@ @D@ @E@ @F(%compareBA@@@@  @@W@#minK@!a @G@@ @H@ @I@ ww w@@X@#maxL@!a @J@@ @K@ @L@  3@@Y@"==M@!a @M@@@ @N@ @O@ @P#%eqBA@@@@  @@7Z@"!=N@!a @Q@@@ @R@ @S@ @T&%noteqBA6@@@@6 !!7 !"%@@Q[@#notO@@@ @U@@ @V@ @W(%boolnotAAN@@@M ""N ""@@h\@"&&P@@@ @X@%@@ @Y)@@ @Z@ @[@ @\(%sequandBAk@@@@k # # l # #3@@]@!&Q@=@@ @]@C@@ @^G@@ @_@ @`@ @a(%sequandBA@@@@ $,$, $_$@0ocaml.deprecated $_$d $_$t@1Use (&&) instead. $_$v $_$@@ $_$u $_$@@@@@ $_$a@@^@"||R@r@@ @b@x@@ @c|@@ @d@ @e@ @f'%sequorBA@@@@ %% %%F@@_@"orS@@@ @g@@@ @h@@ @i@ @j@ @k'%sequorBAܠ@@@@ &=&= &p&@0ocaml.deprecated &p&u &p&@1Use (||) instead. &p& &p&@@ &p& &p&@@@@@ &p&r@@`@'__LOC__T@@ @l(%loc_LOC@A@@ ';'; ';'a@@a@(__FILE__U@@ @m)%loc_FILE@A@@ (G(G (G(o@@.b@(__LINE__V@@ @n)%loc_LINE@A%@@# (($ ()@@>c@*__MODULE__W	@@ @o+%loc_MODULE@A5@@3))4))@@Nd@'__POS__X@@ @s@@ @r@@ @q@@ @p@ @t(%loc_POS@AW@@U*4*4V*4*l@@pe@,__FUNCTION__Y;@@ @u-%loc_FUNCTION@Ag@@e++f+,@@f@*__LOC_OF__Z@!a @vT@@ @w@ @x@ @y(%loc_LOCAA@@@,,,,@@g@+__LINE_OF__[@!a @z4@@ @{@ @|@ @})%loc_LINEAA@@@"--"--@@h@*__POS_OF__\@!a @~@@ @W@@ @\@@ @a@@ @@ @@ @@ @(%loc_POSAAɠ@@@)..)./@@i@"|>]@!a @@@!b @@ @@ @@ @)%revapplyBA@@@@500501@@j@"@@^@@!a @!b @@ @@
@ @@ @&%applyBA @@@@ <11<11@@k@"~-_@@@ @@@ @@ @'%negintAA@@@I3?3?I3?3g@@2l@"~+`@@@ @@@ @@ @)%identityAA/@@@.O33/O34@@Im@$succa@@@ @@@ @@ @(%succintAAF@@@EU44FU44@@`n@$predb@@@ @@@ @@ @(%predintAA]@@@\X44]X45@@wo@!+c@	@@ @@@@ @@@ @@ @@ @'%addintBAz@@@@z[5:5:{[5:5h@@p@!-d@'@@ @@-@@ @1@@ @@ @@ @'%subintBA@@@@`55`55@@q@!*e@E@@ @@K@@ @O@@ @@ @@ @'%mulintBA@@@@e6i6ie6i6@@r@!/f@c@@ @@i@@ @m@@ @@ @@ @'%divintBAԠ@@@@j77j772@@s@#modg@@@ @@@@ @@@ @@ @@ @'%modintBA@@@@u88u89@@
t@#absh@@@ @@@ @@ @@::::@@ u@'max_inti@@ @@;!;!;!;2@@-v@'min_intj@@ @@;_;_ ;_;p@@:w@$landk@@@ @@@@ @@@ @@ @@ @'%andintBA=@@@@=;;>;;@@Xx@#lorl@@@ @@@@ @@@ @@ @@ @Ð&%orintBA[@@@@[<X<X\<X<@@vy@$lxorm@@@ @@@@ @@@ @@ @@ @Ȑ'%xorintBAy@@@@y<<z<=!@@z@$lnotn@&@@ @*@@ @@ @@====@@{@#lslo@9@@ @@?@@ @C@@ @@ @@ @А'%lslintBA@@@@====@@|@#lsrp@W@@ @@]@@ @a@@ @@ @@ @Ր'%lsrintBAȠ@@@@>>>>@@}@#asrq@u@@ @@{@@ @@@ @@ @@ @ڐ'%asrintBA@@@@@	@	@	@9@@~@#~-.r@%floatD@@ @@@ @@ @ݐ)%negfloatAA @@@CC CD@@@#~+.s@@@ @@@ @@ @)%identityAA@@@DDDD@@1 @@"+.t@0@@ @@6@@ @:@@ @@ @@ @)%addfloatBA4@@@@4EdEd5EdE@@O A@"-.u@N@@ @@T@@ @X@@ @@ @@ @)%subfloatBAR@@@@RF	F	SF	F@@@m B@"*.v@l@@ @@r@@ @v@@ @@ @@ @)%mulfloatBAp@@@@pFFqFF@@ C@"/.w@@@ @@@@ @@@ @@ @@ @)%divfloatBA@@@@G\G\G\G@@ D@"**x@@@ @@@@ @@@ @@ @@ @0caml_power_floatB@#powAA@AHHHFH_@'unboxedHFHKHFHR@@HFHHHFHS@'noallocHFHWHFH^@@HFHT@@ E@$sqrty@@@ @@@ @@ @/caml_sqrt_floatA@$sqrtA@AHHHI@'unboxedHIHI@@HIHI@'noallocHIHI@@HI
@@
 F@#expz@	@@ @
@@ @@ @.caml_exp_floatA@#expA@AI.I.I.I|@'unboxedI.IhI.Io@@I.IeI.Ip@'noallocI.ItI.I{@@I.Iq@@7 G@#log{@6@@ @ :@@ @@ @.caml_log_floatA@#logA@A4II5II@'unboxed;II<II@@?II@II@'noallocFIIGII@@JII@@d H@%log10|@c@@ @g@@ @@ @0caml_log10_floatA@%log10A@AaIIbJ9JR@'unboxedhJ9J>iJ9JE@@lJ9J;mJ9JF@'noallocsJ9JJtJ9JQ@@wJ9JG@@ I@%expm1}@@@ @@@ @@ @0caml_expm1_floatA@*caml_expm1A@AJnJnJJ@'unboxedJJJJ@@JJJJ@'noallocJJJJ@@JJ@@ J@%log1p~@@@ @	@@ @
@ @0caml_log1p_floatA@*caml_log1pA@AKNKNKK@'unboxedKKKK@@KKKK@'noallocKKKK@@KK@@ K@#cos@@@ @@@ @
@ @.caml_cos_floatA@#cosA@ALCLCLCL@'unboxedLCL}LCL@@LCLzLCL@'noallocLCLLCL@@LCL@@ L@#sin@@@ @@@ @@ @.caml_sin_floatA@#sinA@ALLLM	@'unboxedLLLL@@ LL!LL@'noalloc'LM(LM@@+LL@@E M@#tan@D@@ @H@@ @@ @.caml_tan_floatA@#tanA@AB
M1M1C
M1M@'unboxedI
M1MkJ
M1Mr@@M
M1MhN
M1Ms@'noallocT
M1MwU
M1M~@@X
M1Mt@@r N@$acos@q@@ @u@@ @@ @/caml_acos_floatA@$acosA@Ao
MMpMM@'unboxedvMMwMM@@zMM{MM@'noallocMMMM@@MM@@ O@$asin@@@ @@@ @@ @/caml_asin_floatA@$asinA@ANNNN@'unboxedNNNN@@NNNN@'noallocNNNN@@NN@@ P@$atan@@@ @@@ @@ @/caml_atan_floatA@$atanA@AO\O\OO@'unboxedOOOO@@OOOO@'noallocOOOO@@OO@@ Q@%atan2@@@ @@@@ @@@ @ @ @!@ @"0caml_atan2_floatB@%atan2AA@APPPGP`@'unboxed	PGPL	PGPS@@	PGPI		PGPT@'noalloc	PGPX	PGP_@@	PGPU@@	- R@%hypot@,@@ @#@2@@ @$6@@ @%@ @&@ @'0caml_hypot_floatB@*caml_hypotAA@A	1"Q"Q"	2#QmQ@'unboxed	8#QmQr	9#QmQy@@	<#QmQo	=#QmQz@'noalloc	C#QmQ~	D#QmQ@@	G#QmQ{@@	a S@$cosh@`@@ @(d@@ @)@ @*/caml_cosh_floatA@$coshA@A	^+RR	_,SS@'unboxed	e,SS	f,SS@@	i,SS	j,SS@'noalloc	p,SS	q,SS@@	t,SS@@	 T@$sinh@@@ @+@@ @,@ @-/caml_sinh_floatA@$sinhA@A	/SQSQ	0SS@'unboxed	0SS	0SS@@	0SS	0SS@'noalloc	0SS	0SS@@	0SS@@	 U@$tanh@@@ @.@@ @/@ @0/caml_tanh_floatA@$tanhA@A	3SS	4TT*@'unboxed	4TT	4TT@@	4TT	4TT@'noalloc	4TT"	4TT)@@	4TT@@	 V@%acosh@@@ @1@@ @2@ @30caml_acosh_floatA@*caml_acoshA@A	7T`T`	8TT@'unboxed	8TT	8TT@@	8TT	8TT@'noalloc	8TT	8TT@@	8TT@@
 W@%asinh@@@ @4@@ @5@ @60caml_asinh_floatA@*caml_asinhA@A
@UbUb
AUU@'unboxed
AUU
AUU@@
AUU
AUU@'noalloc
$AUU
%AUU@@
(AUU@@
B X@%atanh@A@@ @7E@@ @8@ @90caml_atanh_floatA@*caml_atanhA@A
?IVFVF
@JVV@'unboxed
FJVV
GJVV@@
JJVV
KJVV@'noalloc
QJVV
RJVV@@
UJVV@@
o Y@$ceil@n@@ @:r@@ @;@ @</caml_ceil_floatA@$ceilA@A
lRWPWP
mSWW@'unboxed
sSWW
tSWW@@
wSWW
xSWW@'noalloc
~SWW
SWW@@
SWW@@
 Z@%floor@@@ @=@@ @>@ @?0caml_floor_floatA@%floorA@A
XX?X?
YX|X@'unboxed
YX|X
YX|X@@
YX|X~
YX|X@'noalloc
YX|X
YX|X@@
YX|X@@
 [@)abs_float@@@ @@@@ @A@ @B)%absfloatAA
Ơ@@@
_Y6Y6
_Y6Yg@@
 \@(copysign@@@ @C@@@ @D@@ @E@ @F@ @G3caml_copysign_floatB@-caml_copysignAA@A
bYY
dZZ0@'unboxed
dZZ
dZZ#@@
dZZ
dZZ$@'noalloc
dZZ(
dZZ/@@
dZZ%@@ ]@)mod_float@@@ @H@@@ @I@@ @J@ @K@ @L/caml_fmod_floatB@$fmodAA@Ak[![!l[i[@'unboxedl[i[n l[i[u@@#l[i[k$l[i[v@'noalloc*l[i[z+l[i[@@.l[i[w@@H ^@%frexp@G@@ @MN@@ @O
@@ @N@ @P@ @Q0caml_frexp_floatAAM@@@Lq\@\@Mq\@\z@@g _@%ldexp@f@@ @R@
@@ @Sp@@ @T@ @U@ @V0caml_ldexp_floatB@8caml_ldexp_float_unboxedAB@Aky]]lz]^@'noallocrz]^sz]^@@vz]^@@ `@$modf@@@ @W@@ @Y@@ @X@ @Z@ @[/caml_modf_floatAA@@@}^8^8}^8^r@@ a@%float@A@@ @\@@ @]@ @^+%floatofintAA@@@^^^^@@ b@,float_of_int@X@@ @_@@ @`@ @a+%floatofintAAà@@@____N@@ c@(truncate@@@ @bs@@ @c@ @d+%intoffloatAAڠ@@@_}_}_}_@@ d@,int_of_float@@@ @e@@ @f@ @g+%intoffloatAA@@@___`
@@ e@(infinity@@ @h@````@@ f@,neg_infinity@@ @i@
```a@@% g@#nan"@@ @j@aaaa-@@2 h@)max_float/@@ @k@$bb%bb@@? i@)min_float<@@ @l@1bb2bc@@L j@-epsilon_floatI@@ @m@>c^c^?c^cw@@Y k@'fpclass  8 @@)FP_normal p@@MddNdd@@h m,FP_subnormal q@@VdAdCWdAdQ@@q n'FP_zero r@@_dd`dd@@z o+FP_infinite s@@hddidd@@ p&FP_nan t@@qeeree@@ q@@A@@@@@ucc@@A@ lA@.classify_float@@@ @nB@@ @o@ @p3caml_classify_floatA@;caml_classify_float_unboxedA@@eeffD@'noallocff<ffC@@ff9@@ r@!^@~@@ @q@@@ @r@@ @s@ @t@ @u@gggg;@@ s@+int_of_char@$charB@@ @vb@@ @w@ @x)%identityAAɠ@@@hihihih@@ t@+char_of_int@u@@ @y@@ @z@ @{@hhhh@@ u@&ignore@!a @|$unitF@@ @}@ @~'%ignoreAA@@@iiii@@
 v@.string_of_bool@@@ @@@ @@ @@
kk
kk$@@
" w@2bool_of_string_opt@@@ @&optionJ@@ @@@ @@ @@
!kk
"kk@@
< x@.bool_of_string@
	@@ @@@ @@ @@
4lYlY
5lYl|@@
O y@-string_of_int@@@ @
 @@ @@ @@
Gll
Hlm@@
b z@1int_of_string_opt@
/@@ @@@@ @@@ @@ @@
_m_m_
`m_m@@
z {@-int_of_string@
G@@ @
@@ @@ @2caml_int_of_stringAA
w@@@
vpp
wpp@@
 |@/string_of_float@@@ @
b@@ @@ @@

q6q6

q6q[@@
 }@3float_of_string_opt@
q@@ @@@ @@@ @@ @@

qq

qq@@
 ~@/float_of_string@
@@ @@@ @@ @4caml_float_of_stringAA
@@@
%u9u9
%u9u|@@
 @#fst@!a @!b @@ @	@ @'%field0AA
Ԡ@@@
+vv
+vv6@@
 @#snd@!a @!b @@ @@ @'%field1AA
@@@
.veve
.vev@@	 @!@@$listI!a @@@ @@
@@ @@@ @@ @@ @@7ww7ww<@@+ @*in_channel  8 @@@A@@@@@@xXxX@xXxg@@@@4 A@+out_channel  8 @@@A@@@@@"Cxx#Cxx@@@@= A@%stdin@@ @@/Fxx0Fxx@@J @&stdout@@ @@<Iyy=Iyy@@W @&stderr
@@ @@HLyIyIILyIya@@c @*print_char@@@ @m@@ @@ @@[Ryy\Ryy@@v @,print_string@C@@ @@@ @@ @@nUzzoUzz3@@ @+print_bytes@%bytesC@@ @@@ @@ @@Xz_z_Xz_z~@@ @)print_int@0@@ @@@ @@ @@\zz\zz@@ @+print_float@@@ @@@ @@ @@_{{_{{7@@ @-print_endline@@@ @@@ @@ @@b{{b{{@@ @-print_newline@@@ @@@ @@ @@f||f||,@@ @*prerr_char@ @@ @@@ @@ @@n||n|}@@ @,prerr_string@@@ @@@ @@ @@q}?}?q}?}`@@ @+prerr_bytes@@@ @@@ @@ @@t}}	t}}@@# @)prerr_int@@@ @-@@ @@ @@x}}x}~@@6 @+prerr_float@	5@@ @@@@ @@ @@.{~B~B/{~B~a@@I @-prerr_endline@@@ @S@@ @@ @@A~~~B~~~@@\ @-prerr_newline@b@@ @f@@ @@ @@T22U2R@@o @)read_line@u@@ @@@@ @@ @@gh@@ @,read_int_opt@@@ @`@@ @@@ @@ @@        @@ @(read_int@@@ @0@@ @@ @@        @@ @.read_float_opt@@@ @	@@ @@@ @@ @@  1  1  1  Y@@ @*read_float@@@ @	@@ @@ @@  ?  ?  ?  ]@@ @)open_flag  8 @@+Open_rdonly @@    	    @@ +Open_wronly @@  3  5  3  B@@ +Open_append @@  a  c  a  p@@ *Open_creat @@        @@ *Open_trunc @@        @@ )Open_excl @@  1  3  1  >@@ +Open_binary @@  }    }  @@ )Open_text @@        @@& -Open_nonblock @@    	    @@/ @@A@@@@@    @@A@2 A@(open_out@@@ @@@ @@ @@)    *    @@D @,open_out_bin@@@ @ @@ @@ @@;    <    @@V @,open_out_gen@M@@ @@@ @@@@ @@4@@ @#@@ @@ @@ @@ @@^    _    @@y @%flush@1@@ @@@ @@ @@p  e  eq  e  @@ @)flush_all@@@ @@@ @@ @@  j  j  j  @@ @+output_char@V@@ @@@@ @@@ @@ @ @ @@        @@ @-output_string@n@@ @@@@ @@@ @@ @@ @@  %  %  %  V@@ @,output_bytes@@@ @@J@@ @@@ @	@ @
@ @@        @@ @&output@@@ @@b@@ @
@@@ @@@@ @@@ @@ @@ @@ @@ @@        B@@
 @0output_substring@@@ @@@@ @@@@ @@@@ @%@@ @@ @@ @@ @@ @@  .  .  .  p@@. @+output_byte@@@ @@@@ @=@@ @ @ @!@ @"@+    ,    @@F @1output_binary_int@@@ @#@@@ @$U@@ @%@ @&@ @'@C    D    @@^ @,output_value@@@ @(@!a @)m@@ @*@ @+@ @,@[    \    3@@v @(seek_out@.@@ @-@
@@ @.@@ @/@ @0@ @1@s    t    @@ @'pos_out@F@@ @2#@@ @3@ @4@        @@ @2out_channel_length@X@@ @55@@ @6@ @7@        '@@ @)close_out@j@@ @8@@ @9@ @:@        @@ @/close_out_noerr@|@@ @;@@ @<@ @=@        @@ @3set_binary_mode_out@@@ @>@@@ @?@@ @@@ @A@ @B@        .@@ @'open_in@@@ @C@@ @D@ @E@,  7  7,  7  Y@@  @+open_in_bin@@@ @F@@ @G@ @H@0    0    @@ @+open_in_gen@	@@ @I@@ @J@@@ @K@@@ @L@@ @M@ @N@ @O@ @P@6    6    D@@4 @*input_char@@@ @Qm@@ @R@ @S@+=  U  U,=  U  x@@F @*input_line@@@ @T@@ @U@ @V@=A    >A    @@X @%input@@@ @W@@@ @X@@@ @Y@@@ @Z@@ @[@ @\@ @]@ @^@ @_@aH  &  &bH  &  Z@@| @,really_input@A@@ @`@@@ @a@@@ @b@@@ @c@@ @d@ @e@ @f@ @g@ @h@Y    Y    @@ @3really_input_string@e@@ @i@7@@ @jv@@ @k@ @l@ @m@a  3  3a  3  h@@ @*input_byte@}@@ @nM@@ @o@ @p@h  L  Lh  L  n@@ @0input_binary_int@@@ @q_@@ @r@ @s@m    m    .@@ @+input_value@@@ @t!a @u@ @v@s  
  
s  
  ,@@ @'seek_in@@@ @w@@@ @x@@ @y@ @z@ @{@z  c  cz  c  @@ @&pos_in@@@ @|@@ @}@ @~@  D  D  D  b@@ @1in_channel_length@@@ @@@ @ @ @ @        :@@* @(close_in@@@ @ 3@@ @ @ @ @!    "    @@< @.close_in_noerr@@@ @ E@@ @ @ @ @3    4    @@N @2set_binary_mode_in@@@ @ @
@@ @ ]@@ @ @ @ @ @ @K    L    ,@@f @Ӡ)LargeFile@(seek_out8@$@@ @ @%int64M@@ @ }@@ @ @ @ @ @ @k  M  Ql  M  |@@ @'pos_out9@>@@ @ @@ @ @ @ @}  }  ~  }  @@ @2out_channel_length:@P@@ @ *@@ @ @ @ @        @@ @'seek_in;@o@@ @ @>@@ @ @@ @ @ @ @ @ @        @@ @&pos_in<@@@ @ T@@ @ @ @ @        (@@ @1in_channel_length=@@@ @ f@@ @ @ @ @  )  -  )  X@@ @@@  4  4  Y  ^@ @@#ref  8 !a @ @A(contents A	        @@ @@A@ @@@@@        @@@@ A@#ref@!a @ %@@ @ @ @ ,%makemutableAA@@@   g  g  g  @@ @!!@!a @ @@ @ @ @ '%field0AA@@@        @@2 @":=@+!a @ @@ @ @B@@ @ @ @ @ @ *%setfield0BA5@@@@5    6    @@P @$incr@I@@ @ @@ @ ^@@ @ @ @ %%incrAAQ@@@P    Q    @@k @$decr@d @@ @ @@ @ y@@ @ @ @ %%decrAAl@@@k    l    H@@ @&result  8 !a @ !b @ @B"Ok ې@@        @@ ؠ%Error ܐ@@        @@ @@A@YY@@@@@@    @@@@ A@'format6  8 !a @ !b @ !c @ !d @ !e @ !f @ @F@A8CamlinternalFormatBasics'format6&"@@ @  OO OO@@@@@@@@@@  Ĵ  Ĵ    @@@@ A@'format4  8 !a @ à!b @  !c @ !d @ @D@A]@@ @ Ġ O O@@@@@@@@!    	!    Y@@@@# A@&format  8 !a @ Ǡ!b @ Ơ!c @ @C@AF@@ @ Ƞ O @@@@@@@/#  [  [0#  [  Ŏ@@@@J A@0string_of_format@D!a @ Π!b @ ͠!c @ ̠!d @ ˠ!e @ ʠ!f @ @@ @ 8@@ @ @ @ @_%  Ő  Ő`%  Ő  @@z @0format_of_string@t!a @ ؠ!b @ נ!c @ ֠!d @ ՠ!e @ Ԡ!f @ @@ @ !
@@ @ @ @ ڐ)%identityAA@@@(    *  D  t@@ @"^^@!a @ !b @ !c @ !d @ !e @ ܠ!f @ @@ @ @Р
!g @ !h @ @@ @ 40,(
@@ @ @ @ @ @ @2  ǉ  ǉ5    @@ @$exit@@@ @ !a @ @ @ @@  ɽ  ɽ@  ɽ  @@ @'at_exit@@	@@ @ 	@@ @ @ @ 	@@ @ @ @ @I  v  v
I  v  ˚@@' @1valid_float_lexem@@@ @ @@ @ @ @ @X  Ͳ  Ͳ X  Ͳ  @@: @3unsafe_really_input@@@ @ @@@ @ @@@ @ @@@ @ 	U@@ @ @ @ @ @ @ @ @ @ @CZ    DZ    @@^ @*do_at_exit @	d@@ @ 	h@@ @ @ @ @V\  !  !W\  !  >@@q @Ӡ#ArgA+Stdlib__Arg@cd  Ύ  Ύdd  Ύ  Φ@~ @@Ӡ%ArrayA-Stdlib__Array@pg    qg    @ @@Ӡ+ArrayLabelsA3Stdlib__ArrayLabels@}j    ~j    $@ @@Ӡ&AtomicA.Stdlib__Atomic@m  ?  ?m  ?  ]@ @@Ӡ(BigarrayA0Stdlib__Bigarray@p  z  zp  z  Ϝ@ @@Ӡ$BoolA,Stdlib__Bool@s  ϵ  ϵs  ϵ  @ @@Ӡ&BufferA.Stdlib__Buffer@v    v    @ @@Ӡ%BytesA-Stdlib__Bytes@y  "  "y  "  >@ @@Ӡ+BytesLabels	A3Stdlib__BytesLabels@|  ^  ^|  ^  І@ @@Ӡ(Callback
A0Stdlib__Callback@  У  У  У  @ @@Ӡ$CharA,Stdlib__Char@        @  @@Ӡ'ComplexA/Stdlib__Complex@        4@
 @@Ӡ&Digest
A.Stdlib__Digest@  O  O   O  m@ @@Ӡ&EitherA.Stdlib__Either@  ш  ш
  ш  Ѧ@' @@Ӡ)EphemeronA1Stdlib__Ephemeron@        @4 @@Ӡ(FilenameA0Stdlib__Filename@&    '    '@A @@Ӡ%FloatA-Stdlib__Float@3  A  A4  A  ]@N @@Ӡ&FormatA.Stdlib__Format@@  x  xA  x  Җ@[ @@Ӡ#FunA+Stdlib__Fun@M  Ү  ҮN  Ү  @h @@Ӡ"GcA*Stdlib__Gc@Z    [    @u @@Ӡ&GenlexA.Stdlib__Genlex@g    h    ,@ @@Ӡ'HashtblA/Stdlib__Hashtbl@t  H  Hu  H  h@ @@Ӡ#IntA+Stdlib__Int@  Ӏ  Ӏ  Ӏ  Ә@ @@Ӡ%Int32A-Stdlib__Int32@  Ӳ  Ӳ  Ӳ  @ @@Ӡ%Int64A-Stdlib__Int64@        @ @@Ӡ$LazyA,Stdlib__Lazy@        7@ @@Ӡ&LexingA.Stdlib__Lexing@  R  R  R  p@ @@Ӡ$ListA,Stdlib__List@  ԉ  ԉ  ԉ  ԣ@ @@Ӡ*ListLabelsA2Stdlib__ListLabels@        @@@Ӡ#MapA+Stdlib__Map@           @@@Ӡ'MarshalA/Stdlib__Marshal@  4  4  4  T@@@Ӡ*MoreLabels A2Stdlib__MoreLabels@  s  s  s  ՙ@@@Ӡ)Nativeint!A1Stdlib__Nativeint@  շ  շ  շ  @@@Ӡ#Obj"A+Stdlib__Obj@        @+@@Ӡ"Oo#A*Stdlib__Oo@  "  "  "  8@8@@Ӡ&Option$A.Stdlib__Option@*  S  S+  S  q@E@@Ӡ'Parsing%A/Stdlib__Parsing@7  ֍  ֍8  ֍  ֭@R	@@Ӡ*Pervasives&A2Stdlib__Pervasives*deprecatedH    I     @	Use Stdlib instead.

If you need to stay compatible with OCaml < 4.07, you can use the 
stdlib-shims library: https://github.com/ocaml/stdlib-shimsS    T  c  מ@@V    W  c  ן@@@@@Y    Z  c  נ@@\    @v
@@Ӡ(Printexc'A0Stdlib__Printexc@h  ׽  ׽i  ׽  @@@Ӡ&Printf(A.Stdlib__Printf@u    v    @@@Ӡ%Queue)A-Stdlib__Queue@  2  2  2  N@
@@Ӡ&Random*A.Stdlib__Random@  i  i  i  ؇@@@Ӡ&Result+A.Stdlib__Result@  آ  آ  آ  @@@Ӡ%Scanf,A-Stdlib__Scanf@        @@@Ӡ#Seq-A+Stdlib__Seq@        &@@@Ӡ#Set.A+Stdlib__Set@  >  >  >  V@@@Ӡ%Stack/A-Stdlib__Stack@  p  p  p  ٌ@@@Ӡ)StdLabels0A1Stdlib__StdLabels@  ٪  ٪  ٪  @@@Ӡ&Stream1A.Stdlib__Stream@        @@@Ӡ&String2A.Stdlib__String@  "  "  "  @@@@Ӡ,StringLabels3A4Stdlib__StringLabels@  a  a  a  ڋ@@@Ӡ#Sys4A+Stdlib__Sys@  ڣ  ڣ  ڣ  ڻ@,@@Ӡ%Uchar5A-Stdlib__Uchar@        @9@@Ӡ$Unit6A,Stdlib__Unit@+  
  
,  
  $@F@@Ӡ$Weak7A,Stdlib__Weak@8
  =  =9
  =  W@S@@@  #       &Stdlib0-&fºnr39tߠ,Stdlib__Weak@,Stdlib__Unit@-Stdlib__Uchar@+Stdlib__Sys@4Stdlib__StringLabels@.Stdlib__String@.Stdlib__Stream@1Stdlib__StdLabels@-Stdlib__Stack@+Stdlib__Set@+Stdlib__Seq@-Stdlib__Scanf@.Stdlib__Result@.Stdlib__Random@-Stdlib__Queue@.Stdlib__Printf@0Stdlib__Printexc@2Stdlib__Pervasives@/Stdlib__Parsing@.Stdlib__Option@*Stdlib__Oo@+Stdlib__Obj@1Stdlib__Nativeint@2Stdlib__MoreLabels@/Stdlib__Marshal@+Stdlib__Map@2Stdlib__ListLabels@,Stdlib__List@.Stdlib__Lexing@,Stdlib__Lazy@-Stdlib__Int64@-Stdlib__Int32@+Stdlib__Int@/Stdlib__Hashtbl@.Stdlib__Genlex@*Stdlib__Gc@+Stdlib__Fun@.Stdlib__Format@-Stdlib__Float@0Stdlib__Filename@1Stdlib__Ephemeron@.Stdlib__Either@.Stdlib__Digest@/Stdlib__Complex@,Stdlib__Char@0Stdlib__Callback@3Stdlib__BytesLabels@-Stdlib__Bytes@.Stdlib__Buffer@,Stdlib__Bool@0Stdlib__Bigarray@.Stdlib__Atomic@3Stdlib__ArrayLabels@-Stdlib__Array@+Stdlib__Arg@8CamlinternalFormatBasics0ĵ'(jd@            @@                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Caml1999Z030  ^  2  6  -  ( 8CamlinternalFormatBasics@0ĵ'(jd@@B@@@@@0=TBAQ   ( 2CamlinternalAtomic@0zo{I;@@CB@@@
@0uJ:@wh  ( &Stdlib@,Stdlib__Weak@,Stdlib__Unit@-Stdlib__Uchar@+Stdlib__Sys@4Stdlib__StringLabels@.Stdlib__String@.Stdlib__Stream@1Stdlib__StdLabels@-Stdlib__Stack@+Stdlib__Set@+Stdlib__Seq@-Stdlib__Scanf@.Stdlib__Result@.Stdlib__Random@-Stdlib__Queue@.Stdlib__Printf@0Stdlib__Printexc@2Stdlib__Pervasives@/Stdlib__Parsing@.Stdlib__Option@*Stdlib__Oo@+Stdlib__Obj@1Stdlib__Nativeint@2Stdlib__MoreLabels@/Stdlib__Marshal@+Stdlib__Map@2Stdlib__ListLabels@,Stdlib__List@.Stdlib__Lexing@,Stdlib__Lazy@-Stdlib__Int64@-Stdlib__Int32@+Stdlib__Int@/Stdlib__Hashtbl@.Stdlib__Genlex@*Stdlib__Gc@+Stdlib__Fun@.Stdlib__Format@-Stdlib__Float@0Stdlib__Filename@1Stdlib__Ephemeron@.Stdlib__Either@.Stdlib__Digest@/Stdlib__Complex@,Stdlib__Char@0Stdlib__Callback@3Stdlib__BytesLabels@-Stdlib__Bytes@.Stdlib__Buffer@,Stdlib__Bool@0Stdlib__Bigarray@.Stdlib__Atomic@3Stdlib__ArrayLabels@-Stdlib__Array@+Stdlib__Arg@0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jdǠ2CamlinternalAtomic0zo{I;@8CamlinternalFormatBasics0=TBAQ 2CamlinternalAtomic0uJ:@wh@DCB@@@@0~tV*e   ( 2Stdlib__Pervasives@0/|rkU
@ڠ&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@&Stdlib0~tV*e @@@@@0^kk=r&XnV  ( +Stdlib__Seq@0Jd8_mJk&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@@BC@B@@@0x'~Rr7Ox  ( .Stdlib__Option@+Stdlib__Seq0Jd8_mJk	0L@93|l&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Seq0x'~Rr7Ox&Stdlib0~tV*e @BC@B@@)@0}IHRi  ( .Stdlib__Either@0$_ʩ<&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@@BCD@B@@A@0H֯fe}\  ( .Stdlib__Result@+Stdlib__Seq0Jd8_mJk	0Y	5F[9o&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Seq0x'~Rr7Ox&Stdlib0~tV*e @DCB@B@@h@0ҰwW~  ( ,Stdlib__Bool@0!Vי;q0-*(&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@@B@@@}@0/}7;LgI֠  ( ,Stdlib__Char@0a'xPVCw"ڠ&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@&Stdlib0~tV*e @B@@@@0dJ^G_ȿ鮎  ( -Stdlib__Uchar@0o9us:2[],Stdlib__Char0a'xPVCw"ڠ&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@&Stdlib0~tV*e @B@@@@0[wmN擀i  ( +Stdlib__Sys@0wg1XƮ"~7&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@&Stdlib0~tV*e @B@@@@0:eW -b:U  ( ,Stdlib__List@+Stdlib__Sys0wg1XƮ"~7+Stdlib__Seq0Jd8_mJk0U#r&L.Stdlib__Either0$_ʩ<&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U+Stdlib__Seq0x'~Rr7Ox&Stdlib0~tV*e @DBC@CB@@@0!?$JOjĠ  ( +Stdlib__Int@0ʬ<xyd&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@@B@@@@0W0F*3濠  ( -Stdlib__Bytes@+Stdlib__Sys0wg1XƮ"~7+Stdlib__Seq0Jd8_mJk+Stdlib__Int0ʬ<xyd,Stdlib__Char0a'xPVCw"ڠ0G`çVYXq&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U+Stdlib__Seq0x'~Rr7Ox+Stdlib__Int0W0F*3濠,Stdlib__Char0dJ^G_ȿ鮎&Stdlib0~tV*e @EDCB@B@@b@03tjz
FwDyh  ( .Stdlib__String@0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk-Stdlib__Bytes0G`çVYXq&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@-Stdlib__Bytes03tjz
FwDyh&Stdlib0~tV*e @EDCB@B@@@0W\'"IĒ  ( ,Stdlib__Unit@02U8|L^ N&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@@B@@@@0kz
!ϓ	  ( /Stdlib__Marshal@+Stdlib__Seq0Jd8_mJk	0Ibl*__,0-Stdlib__Bytes0G`çVYXq&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@-Stdlib__Bytes03tjz
FwDyh&Stdlib0~tV*e @CEB@@@@0BUx	s  ( +Stdlib__Obj@+Stdlib__Sys0wg1XƮ"~7	0_bE@Xt1Stdlib__Nativeint0 oB	(/Stdlib__Marshal0Ibl*__,0-Stdlib__Int320Z(I&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U/Stdlib__Marshal0BUx	s&Stdlib0~tV*e @EBC@@@	@0ɏNJ"fn  ( -Stdlib__Array@+Stdlib__Seq0Jd8_mJk	0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Seq0x'~Rr7Ox&Stdlib0~tV*e @ECDGB@B@@2@0Hw
@  ( -Stdlib__Float@+Stdlib__Seq0Jd8_mJk,Stdlib__List0U#r&L0DoAAyՋk.Stdlib__Either0$_ʩ<-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Seq0x'~Rr7Ox,Stdlib__List0!?$JOjĠ0Hw
@&Stdlib0~tV*e @ECDGB@B@@s@0:U mq  ( -Stdlib__Int32@+Stdlib__Sys0wg1XƮ"~7	0Z(I&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U&Stdlib0~tV*e @B@@@@0؝> _Zc邠  ( -Stdlib__Int64@0UY*#/F]&$&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@&Stdlib0~tV*e @B@@@@0"rԓni;Fᠠ  ( 1Stdlib__Nativeint@+Stdlib__Sys0wg1XƮ"~7	0 oB	(&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U&Stdlib0~tV*e @B@@@@0X92}:  ( .Stdlib__Lexing@+Stdlib__Sys0wg1XƮ"~7.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk0XVC[E+Stdlib__Int0ʬ<xyd-Stdlib__Bytes0G`çVYXq-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U+Stdlib__Int0W0F*3濠-Stdlib__Bytes03tjz
FwDyh&Stdlib0~tV*e @CB@B@@@0:w{AX  ( /Stdlib__Parsing@+Stdlib__Seq0Jd8_mJk	0оUXDľdE+Stdlib__Obj0_bE@Xt.Stdlib__Lexing0XVC[E-Stdlib__Int320Z(I-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Obj0ɏNJ"fn.Stdlib__Lexing0:w{AX-Stdlib__Array0Hw
@&Stdlib0~tV*e @DB@@@a@0<{ōv}7  ( +Stdlib__Set@0b)uǑ
bQ8+Stdlib__Seq0Jd8_mJk,Stdlib__List0U#r&L.Stdlib__Either0$_ʩ<&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Seq0x'~Rr7Ox,Stdlib__List0!?$JOjĠ&Stdlib0~tV*e @CB@B@@@0Znh XA  ( +Stdlib__Map@+Stdlib__Seq0Jd8_mJk	0@mŘ`rnࠠ&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Seq0x'~Rr7Ox&Stdlib0~tV*e @DBC@CB@@@0	1)`|(p  ( -Stdlib__Stack@0a[(Bߠ+Stdlib__Seq0Jd8_mJk,Stdlib__List0U#r&L.Stdlib__Either0$_ʩ<&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Seq0x'~Rr7Ox,Stdlib__List0!?$JOj@CB@@@@0(G8  ( -Stdlib__Queue@+Stdlib__Seq0Jd8_mJk	0k!1\
!kҹ[~&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Seq0x'~Rr7Ox@BC@B@@@0
.mAK  ( 0CamlinternalLazy@+Stdlib__Sys0wg1XƮ"~7+Stdlib__Obj0_bE@Xt-Stdlib__Int320Z(I&Stdlib0-&fºnr39tߠ01H^(YPhOD5g8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Obj0ɏNJ"fn&Stdlib0~tV*e @@@@;@0bS:pقh".}  ( ,Stdlib__Lazy@+Stdlib__Obj0_bE@Xt	09=C;!7-Stdlib__Int320Z(I&Stdlib0-&fºnr39tߠ0CamlinternalLazy01H^(YPhOD5g8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Obj0ɏNJ"fn&Stdlib0~tV*e 0CamlinternalLazy0bS:pقh".}@B@@@n@0Gzqt~&  ( .Stdlib__Stream@.Stdlib__String0.BdJP.F4Y3	0P_Z]|h+Stdlib__Seq0Jd8_mJk,Stdlib__List0U#r&L,Stdlib__Lazy09=C;!7.Stdlib__Either0$_ʩ<-Stdlib__Bytes0G`çVYXq&Stdlib0-&fºnr39tߠ0CamlinternalLazy01H^(YPhOD5g8CamlinternalFormatBasics0ĵ'(jd@,Stdlib__List0!?$JOjĠ03tjz
FwDyh&Stdlib0~tV*e 0CamlinternalLazy0bS:pقh".}@B@@@@0g1 *ӯ+  ( .Stdlib__Buffer@-Stdlib__Uchar0o9us:2[]+Stdlib__Sys0wg1XƮ"~7.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk,Stdlib__Char0a'xPVCw"ڠ-Stdlib__Bytes0G`çVYXq"0ok
Vj&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@-Stdlib__Uchar0[wmN擀i+Stdlib__Sys0:eW -b:U.Stdlib__String0W\'"IĒ+Stdlib__Seq0x'~Rr7Ox-Stdlib__Bytes03tjz
FwDyh&Stdlib0~tV*e @DECB@@@
@0Cr`M-i  ( 2CamlinternalFormat@-Stdlib__Uchar0o9us:2[]+Stdlib__Sys0wg1XƮ"~7.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk+Stdlib__Int0ʬ<xyd,Stdlib__Char0a'xPVCw"ڠ-Stdlib__Bytes0G`çVYXq.Stdlib__Buffer0ok
Vj&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jdǠ60>R)7>RXF{@+Stdlib__Sys0:eW -b:U.Stdlib__String0W\'"IĒ+Stdlib__Int0W0F*3濠,Stdlib__Char0dJ^G_ȿ鮎-Stdlib__Bytes03tjz
FwDyh.Stdlib__Buffer0Cr`M-i&Stdlib0~tV*e 8CamlinternalFormatBasics0=TBAQ @GEIJKFDCB@EDCB@@~@0,是aM`  ( .Stdlib__Printf@-Stdlib__Uchar0o9us:2[]+Stdlib__Seq0Jd8_mJk0pJUX빃Ύ.Stdlib__Buffer0ok
Vj&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jdǠ2CamlinternalFormat0>R)7>RXF{@.Stdlib__Buffer0Cr`M-i&Stdlib0~tV*e 2CamlinternalFormat0,是aM`@BC@@@@0TF	zhrj  ( +Stdlib__Arg@-Stdlib__Uchar0o9us:2[]+Stdlib__Sys0wg1XƮ"~7.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk.Stdlib__Printf0pJUX빃Ύ,Stdlib__List0U#r&L+Stdlib__Int0ʬ<xyd.Stdlib__Either0$_ʩ<.Stdlib__Buffer0ok
Vj-Stdlib__Array0XUJө
	ƿ860@)6:
Z$o4*&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@;0:eW -b:U.Stdlib__String0W\'"IĒ.Stdlib__Printf0TF	zhrj,Stdlib__List0!?$JOjĠ+Stdlib__Int0W0F*3濠.Stdlib__Buffer0Cr`M-i-Stdlib__Array0Hw
@&Stdlib0~tV*e @DFECB@DCB@@,@0hD7s{ rOF  ( .Stdlib__Atomic@0#e/Gyt&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jdǠ2CamlinternalAtomic0zo{I;@2CamlinternalAtomic0uJ:@wh@@@@J@0i{+؇'﷠  ( 0Stdlib__Printexc@-Stdlib__Uchar0o9us:2[]+Stdlib__Seq0Jd8_mJk.Stdlib__Printf0pJUX빃Ύ0&\cMv>fN+Stdlib__Obj0_bE@Xt-Stdlib__Int320Z(I.Stdlib__Buffer0ok
Vj.Stdlib__Atomic0#e/Gyt-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@.Stdlib__Printf0TF	zhrj+Stdlib__Obj0ɏNJ"fn.Stdlib__Buffer0Cr`M-i.Stdlib__Atomic0i{+؇'﷠&Stdlib0~tV*e @B@EGB@@@0IWdvpܠ  ( +Stdlib__Fun@0Stdlib__Printexc0&\cMv>fN	0Wk9H\ߠ&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@0Stdlib__Printexc0IWdvpܠ&Stdlib0~tV*e @CB@B@@@0iEMaE5  ( *Stdlib__Gc@-Stdlib__Uchar0o9us:2[]+Stdlib__Sys0wg1XƮ"~7.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk.Stdlib__Printf0pJUX빃Ύ0Stdlib__Printexc0&\cMv>fN"0v#".Stdlib__Buffer0ok
Vj&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U.Stdlib__Printf0TF	zhrj&Stdlib0~tV*e @BC@B@@@0
Q~={  ( .Stdlib__Digest@.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk0Bł[5	>շ,Stdlib__Char0a'xPVCw"ڠ-Stdlib__Bytes0G`çVYXq&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@.Stdlib__String0W\'"IĒ,Stdlib__Char0dJ^G_ȿ鮎-Stdlib__Bytes03tjz
FwDyh&Stdlib0~tV*e @BC@@@P@0 9%a{
n=:  ( .Stdlib__Random@.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk0&l;u|Z>){]1Stdlib__Nativeint0 oB	(-Stdlib__Int640UY*#/F]&$-Stdlib__Int320Z(I+Stdlib__Int0ʬ<xyd.Stdlib__Digest0Bł[5	>շ,Stdlib__Char0a'xPVCw"ڠ-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@1Stdlib__Nativeint0X92}:-Stdlib__Int640"rԓni;Fᠠ-Stdlib__Int320؝> _Zc邠+Stdlib__Int0W0F*3濠.Stdlib__Digest0 9%a{
n=:-Stdlib__Array0Hw
@&Stdlib0~tV*e @B@@@@0.JiKN&4X  ( /Stdlib__Hashtbl@+Stdlib__Sys0wg1XƮ"~7.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk.Stdlib__Random0&l;u|Z>){]+Stdlib__Obj0_bE@Xt1Stdlib__Nativeint0 oB	(,Stdlib__Lazy09=C;!7-Stdlib__Int640UY*#/F]&$-Stdlib__Int320Z(I+Stdlib__Int0ʬ<xyd60a
~Xӭ-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ0CamlinternalLazy01H^(YPhOD5g8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U.Stdlib__String0W\'"IĒ+Stdlib__Seq0x'~Rr7Ox.Stdlib__Random0.JiKN&4X+Stdlib__Int0W0F*3濠-Stdlib__Array0Hw
@&Stdlib0~tV*e 0CamlinternalLazy0bS:pقh".}@D ECB@CB@@	4@0r<MSZll-r/  ( ,Stdlib__Weak@0tqv}HT:r:+Stdlib__Sys0wg1XƮ"~7+Stdlib__Seq0Jd8_mJk+Stdlib__Obj0_bE@Xt-Stdlib__Int320Z(I+Stdlib__Int0ʬ<xyd/Stdlib__Hashtbl0a
~Xӭ-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U+Stdlib__Obj0ɏNJ"fn+Stdlib__Int0W0F*3濠-Stdlib__Array0Hw
@&Stdlib0~tV*e @DCBE@CB@@	@0QOR՜`  ( .Stdlib__Format@-Stdlib__Uchar0o9us:2[].Stdlib__String0.BdJP.F4Y3-Stdlib__Stack0a[(Bߠ+Stdlib__Seq0Jd8_mJk-Stdlib__Queue0k!1\
!kҹ[~,Stdlib__List0U#r&L+Stdlib__Int0ʬ<xyd'0~RsogJyc.Stdlib__Either0$_ʩ<-Stdlib__Bytes0G`çVYXq.Stdlib__Buffer0ok
Vj&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jdǠ2CamlinternalFormat0>R)7>RXF{@.Stdlib__String0W\'"IĒ-Stdlib__Stack0(G8-Stdlib__Queue0
.mAK,Stdlib__List0!?$JOjĠ+Stdlib__Int0W0F*3濠-Stdlib__Bytes03tjz
FwDyh.Stdlib__Buffer0Cr`M-i&Stdlib0~tV*e 2CamlinternalFormat0,是aM`@ECBD@CB@@
@0*~~5aƠ  ( -Stdlib__Scanf@-Stdlib__Uchar0o9us:2[].Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk0̌gJ$}Ӡ.Stdlib__Printf0pJUX빃Ύ,Stdlib__List0U#r&L+Stdlib__Int0ʬ<xyd.Stdlib__Either0$_ʩ<-Stdlib__Bytes0G`çVYXq.Stdlib__Buffer0ok
Vj&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jdǠ2CamlinternalFormat0>R)7>RXF{@.Stdlib__String0W\'"IĒ.Stdlib__Printf0TF	zhrj,Stdlib__List0!?$JOjĠ+Stdlib__Int0W0F*3濠-03tjz
FwDyh.Stdlib__Buffer0Cr`M-i&Stdlib0~tV*e 8CamlinternalFormatBasics0=TBAQ 2CamlinternalFormat0,是aM`@GDCB@BC@@
@0Ku1Tf@$	  ( 0Stdlib__Callback@+Stdlib__Obj0_bE@Xt-Stdlib__Int320Z(I0vit@WesI^&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Obj0ɏNJ"fn&Stdlib0~tV*e @B@@@
@0ِ**{f+ ,-  ( .CamlinternalOO@+Stdlib__Sys0wg1XƮ"~7.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk+Stdlib__Obj0_bE@Xt+Stdlib__Map0@mŘ`rnࠠ,Stdlib__List0U#r&L-Stdlib__Int320Z(I.Stdlib__Either0$_ʩ<,Stdlib__Char0a'xPVCw"ڠ-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ;0
,&'(w38CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U+Stdlib__Obj0ɏNJ"fn+Stdlib__Map0	1)`|(p,Stdlib__List0!?$JOjĠ-Stdlib__Array0Hw
@&Stdlib0~tV*e @FEDCB@B@@@@0ϻcRf	`mb  ( *Stdlib__Oo@0vJOU&u
Z+Stdlib__Obj0_bE@Xt-Stdlib__Int320Z(I&Stdlib0-&fºnr39tߠ.CamlinternalOO0
,&'(w38CamlinternalFormatBasics0ĵ'(jd@.CamlinternalOO0ϻcRf	`mb@@@@<@0:W*D~  ( /CamlinternalMod@+Stdlib__Seq0Jd8_mJk+Stdlib__Obj0_bE@Xt,Stdlib__Lazy09=C;!7-Stdlib__Int320Z(I-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ.CamlinternalOO0
,&'(w3'0'>-ΰh00CamlinternalLazy01H^(YPhOD5g8CamlinternalFormatBasics0ĵ'(jd@,0ɏNJ"fn&Stdlib0~tV*e .CamlinternalOO0ϻcRf	`mb0CamlinternalLazy0bS:pقh".}@BDC@@@@0C
"Y;mTu  ( .Stdlib__Genlex@.Stdlib__String0.BdJP.F4Y3.Stdlib__Stream0P_Z]|h+Stdlib__Seq0Jd8_mJk,Stdlib__List0U#r&L/Stdlib__Hashtbl0a
~Xӭ0c) Š.Stdlib__Either0$_ʩ<,Stdlib__Char0a'xPVCw"ڠ-Stdlib__Bytes0G`çVYXq&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@.Stdlib__String0W\'"IĒ.Stdlib__Stream0g1 *ӯ+,Stdlib__List0!?$JOjĠ/Stdlib__Hashtbl0r<MSZll-r/,Stdlib__Char0dJ^G_ȿ鮎-Stdlib__Bytes03tjz
FwDyh&Stdlib0~tV*e @@@@@0 mSXX  ( 1Stdlib__Ephemeron@+Stdlib__Sys0wg1XƮ"~7+Stdlib__Seq0Jd8_mJk.Stdlib__Random0&l;u|Z>){]+Stdlib__Obj0_bE@Xt1Stdlib__Nativeint0 oB	(,Stdlib__Lazy09=C;!7-Stdlib__Int640UY*#/F]&$-Stdlib__Int320Z(I+Stdlib__Int0ʬ<xyd/Stdlib__Hashtbl0a
~Xӭ60==yu.~YK-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ0CamlinternalLazy01H^(YPhOD5g8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U+Stdlib__Seq0x'~Rr7Ox.Stdlib__Random0.JiKN&4X+Stdlib__Obj0ɏNJ"fn+Stdlib__Int0W0F*3濠/Stdlib__Hashtbl0r<MSZll-r/-Stdlib__Array0Hw
@&Stdlib0~tV*e 0CamlinternalLazy0bS:pقh".}@E CB@CB@@k@0G}竀z(  ( 0Stdlib__Filename@-Stdlib__Uchar0o9us:2[]+Stdlib__Sys0wg1XƮ"~7.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk.Stdlib__Random0&l;u|Z>){].Stdlib__Printf0pJUX빃Ύ1Stdlib__Nativeint0 oB	(,Stdlib__List0U#r&L,Stdlib__Lazy09=C;!7-Stdlib__Int640UY*#/F]&$-Stdlib__Int320Z(I;0Hʉi7/-.Stdlib__Either0$_ʩ<.Stdlib__Buffer0ok
Vj&Stdlib0-&fºnr39tߠ0CamlinternalLazy01H^(YPhOD5g8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U.Stdlib__String0W\'"IĒ.Stdlib__Random0.JiKN&4X.Stdlib__Printf0TF	zhrj,Stdlib__List0!?$JOjĠ.Stdlib__Buffer0Cr`M-i&Stdlib0~tV*e 0CamlinternalLazy0bS:pقh".}@CBE@BC@@@0quoN#nS
  ( /Stdlib__Complex@0[4Z];f:&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@&Stdlib0~tV*e @B@@@
@0Ghp\=  ( 3Stdlib__ArrayLabels@+Stdlib__Seq0Jd8_mJk	0;B
fmzt5-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@-Stdlib__Array0Hw
@@@@@
/@0YZxM@p頠  ( 2Stdlib__ListLabels@+Stdlib__Seq0Jd8_mJk	0ڏEqH7⠠,Stdlib__List0U#r&L.Stdlib__Either0$_ʩ<&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@,Stdlib__List0!?$JOj@@@@
W@0M#̦fNNeà  ( 3Stdlib__BytesLabels@+Stdlib__Seq0Jd8_mJk	0}1vj'UDB-Stdlib__Bytes0G`çVYXq&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@-Stdlib__Bytes03tjz
FwDyh@@@@
z@0"¬.>2$8yZw  ( 4Stdlib__StringLabels@05OҹހA]^.Stdlib__String0.BdJP.F4Y3+Stdlib__Seq0Jd8_mJk&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@.Stdlib__String0W\'"IĒ@@@@
@0~.Nxٰmcxg  ( 2Stdlib__MoreLabels@+Stdlib__Set0b)uǑ
bQ8+Stdlib__Seq0Jd8_mJk0S
P:d+Stdlib__Map0@mŘ`rnࠠ/Stdlib__Hashtbl0a
~Xӭ&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Set0Znh XA+Stdlib__Map0	1)`|(p/Stdlib__Hashtbl0r<MSZll-r/@@@@
@0>QK}ߝ8=  ( 1Stdlib__StdLabels@0A,pW{:l+@&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@@@@@
@0hWV8y%/  ( 0Stdlib__Bigarray@+Stdlib__Sys0wg1XƮ"~7+Stdlib__Seq0Jd8_mJk/Stdlib__Complex0[4Z];f:0X0cO#W-,a-Stdlib__Array0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Sys0:eW -b:U-Stdlib__Array0Hw
@&Stdlib0~tV*e @EFCDB@BC@@&@0E<,hb@@@                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Caml1999Y030  	  &  c    ( -Stdlib__Array@+Stdlib__Seq0Jd8_mJk	0XUJө
	ƿ8&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@+Stdlib__Seq0x'~Rr7Ox&Stdlib0~tV*e @ECDGB@B@@   	 camlStdlib__Array__make_float_95AA$prim@4caml_make_float_vectAA @@@
@    (array.mldQ]dA8Stdlib__Array.make_float>Stdlib__Array.make_float.(fun)@A@;camlStdlib__Array__init_103BA@A@	"camlStdlib__Array__make_matrix_109CA@A@=camlStdlib__Array__append_121BA@A@:camlStdlib__Array__fun_530AA @1caml_array_concatAA@@@@@A@:camlStdlib__Array__sub_126CA@A@;camlStdlib__Array__copy_117AA@A@;camlStdlib__Array__fill_131DA@A@;camlStdlib__Array__blit_137EA@A@>camlStdlib__Array__to_list_183AA@A@>camlStdlib__Array__of_list_193AA@A@;camlStdlib__Array__iter_144BA@A@<camlStdlib__Array__iteri_171BA@A@:camlStdlib__Array__map_155BA@A@;camlStdlib__Array__mapi_176BA@A@	 camlStdlib__Array__fold_left_204CA@A@	$camlStdlib__Array__fold_left_map_211CA@A@	!camlStdlib__Array__fold_right_224CA@A@<camlStdlib__Array__iter2_149CA@A@;camlStdlib__Array__map2_162CA@A@>camlStdlib__Array__for_all_238BA@A@=camlStdlib__Array__exists_231BA@A@?camlStdlib__Array__for_all2_245CA@A@>camlStdlib__Array__exists2_254CA@A@:camlStdlib__Array__mem_263BA@A@;camlStdlib__Array__memq_270BA@A@?camlStdlib__Array__find_opt_277BA@A@?camlStdlib__Array__find_map_285BA@A@<camlStdlib__Array__split_293AA@A@>camlStdlib__Array__combine_304BA@A@;camlStdlib__Array__sort_313BA@A@	"camlStdlib__Array__stable_sort_353BA@A@=camlStdlib__Array__to_seq_397AA@A:camlStdlib__Array__fun_669A@#arg#env@:camlStdlib__Array__aux_400B	@@C@@@    BG,u,uA4Stdlib__Array.to_seq:Stdlib__Array.to_seq.(fun)@A@>camlStdlib__Array__to_seqi_423AA@A:camlStdlib__Array__fun_693A@#"@:camlStdlib__Array__aux_426B@@
C@@@    BG--A5Stdlib__Array.to_seqi;Stdlib__Array.to_seqi.(fun)@A@=camlStdlib__Array__of_seq_442AA@A@4camlStdlib__Array__1@@	"camlStdlib__Array__list_length_189BA$accu %param @A@     Xc A9Stdlib__Array.list_length?Stdlib__Array.list_length.(fun)@A@     DH 
@@     Le @A@5camlStdlib__Array__123Stdlib.Array.Bottom@E	"camlStdlib__Array__of_rev_list_430AA@A@@Hw
@                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Caml1999I030       !  .Stdlib__Atomic!t Z  8 !a @ @A@A@O@B@@@*atomic.mli^^@@@@@A@$make [@!a @ @@ @ @ @ @a""a"7@@&A@#get \@!a @ @@ @ @ @ @(doo)do@@9B@#set ]@#!a @ @@ @ @$unitF@@ @ @ @ @ @ @CgDg@@TC@(exchange ^@>!a @ @@ @ @@ @ @ @ @Xj##Yj#B@@iD@/compare_and_set _@S!a @ @@ @ @@	$boolE@@ @ @ @ @ @ @ @ @uq	W	Wvq	W	@@E@-fetch_and_add `@p#intA@@ @ @@ @ @	@@ @ 
@@ @ @ @ @ @ @u

u

2@@F@$incr a@@@ @ @@ @ j@@ @ @ @ @x
s
sx
s
@@G@$decr b@6@@ @ @@ @ @@ @ @ @ @{

{

@@H@@   l      :   ..Stdlib__Atomic0#e/Gyt&Stdlib0-&fºnr39tߠ8CamlinternalFormatBasics0ĵ'(jd@            @@                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        77c69f8faad395a584cc682952786dfc  usr/bin/find
ae9ab3b8498cea8fce2c31ee287dac51  usr/bin/xargs
f78e2d4189be58135a915698efe1cd7a  usr/share/doc-base/findutils.findutils
75ca1d03fcbb9d988ff479d6c9ca6349  usr/share/doc/findutils/NEWS.Debian.gz
bd89a9df9396614704073d690617af10  usr/share/doc/findutils/NEWS.gz
1dee84120f907a8a0c98300a4bd8f70e  usr/share/doc/findutils/README.gz
95c7c4265ee5c7b9e67d0183d25c13d9  usr/share/doc/findutils/TODO
2815f2e3daaade334f2bb682deb72cec  usr/share/doc/findutils/changelog.Debian.gz
88586ad5c040cc3dd3ec205a1117addd  usr/share/doc/findutils/changelog.gz
0f8dbd7d4e91c384f4cd76a9234ffdfb  usr/share/doc/findutils/copyright
495db52f99bd799da1a2c4c8177d116d  usr/share/info/find-maint.info.gz
a4a5639962311edf0dffca95fb7f5534  usr/share/info/find.info-1.gz
a9d5adafc1cd14c179e8306345cb5c19  usr/share/info/find.info-2.gz
3977fd270ea225601ed2fe1e363bd7d4  usr/share/info/find.info.gz
da0b43bb3ab589cee0d08fac9eacd374  usr/share/locale/be/LC_MESSAGES/findutils.mo
705805c4912d21bb0ccd0f463a8d6e5e  usr/share/locale/bg/LC_MESSAGES/findutils.mo
0e049a51bac1463e942302aa79662c70  usr/share/locale/ca/LC_MESSAGES/findutils.mo
932234736a5f8a20c7a28fba77842363  usr/share/locale/cs/LC_MESSAGES/findutils.mo
ee2e47c6a5fd1a211188e62119928e23  usr/share/locale/da/LC_MESSAGES/findutils.mo
520fa532abcb646e0f43cdaf6aee41d3  usr/share/locale/de/LC_MESSAGES/findutils.mo
c6397ef848f38bedfd0deababa076b29  usr/share/locale/el/LC_MESSAGES/findutils.mo
afa1daa74522ffd5efaa48fcf0dbbd21  usr/share/locale/eo/LC_MESSAGES/findutils.mo
cf3fba2b57bd43ba5ceb53f08eec4d70  usr/share/locale/es/LC_MESSAGES/findutils.mo
125a3643ebac3094098ae386bea23e6e  usr/share/locale/et/LC_MESSAGES/findutils.mo
1b591083bda12033fdb57cec60735fce  usr/share/locale/fi/LC_MESSAGES/findutils.mo
5a61cecb7ac19508f2a6c90ca3aefe4b  usr/share/locale/fr/LC_MESSAGES/findutils.mo
2969f24f51d6f519cbeffd60fdb73158  usr/share/locale/ga/LC_MESSAGES/findutils.mo
70363a8bf3c1f5cae5a0e7de27b2adc0  usr/share/locale/gl/LC_MESSAGES/findutils.mo
ad484875bf02434e68673415195c553b  usr/share/locale/hr/LC_MESSAGES/findutils.mo
88cd877029212d48ee2fc054e532688d  usr/share/locale/hu/LC_MESSAGES/findutils.mo
2b5294097078cfb97fe9aac16423657d  usr/share/locale/id/LC_MESSAGES/findutils.mo
276a3610103231a25b54f751d69fdd48  usr/share/locale/it/LC_MESSAGES/findutils.mo
f330a82946084d650236fd55d308e999  usr/share/locale/ja/LC_MESSAGES/findutils.mo
3d57e7bc20e23f680e291cb208382bd3  usr/share/locale/ko/LC_MESSAGES/findutils.mo
e39a70f1fd80b5452a3d7364cd6f3a5a  usr/share/locale/lg/LC_MESSAGES/findutils.mo
99cd315f836f6b19f9cb57416fcc9984  usr/share/locale/lt/LC_MESSAGES/findutils.mo
ad8a27e26854aeddb2a68bc02fc5b28d  usr/share/locale/ms/LC_MESSAGES/findutils.mo
e575694e26fd089a38f6fd639e0b53fa  usr/share/locale/nb/LC_MESSAGES/findutils.mo
7281681a563f06785bd0bba229e49ca4  usr/share/locale/nl/LC_MESSAGES/findutils.mo
0ddeb79f00ee44ac945960e5976c0837  usr/share/locale/pl/LC_MESSAGES/findutils.mo
d37bc4db999f689042cad033c1c9479a  usr/share/locale/pt/LC_MESSAGES/findutils.mo
cc91c0952b509f220b7fd31e058a9d31  usr/share/locale/pt_BR/LC_MESSAGES/findutils.mo
0d81b2bd19c0e3196b03afc59ad7c542  usr/share/locale/ro/LC_MESSAGES/findutils.mo
5754d744f18a55c0e028b4e7fadac92f  usr/share/locale/ru/LC_MESSAGES/findutils.mo
596a1d5a98421d1748a17edbe40588f5  usr/share/locale/sk/LC_MESSAGES/findutils.mo
a74dcf106a74726e261ab295ea907775  usr/share/locale/sl/LC_MESSAGES/findutils.mo
d6713fcc97d5ade0d93ce8edebf0bb9d  usr/share/locale/sr/LC_MESSAGES/findutils.mo
8c629c57bccd46dbf98a422c1cdd9989  usr/share/locale/sv/LC_MESSAGES/findutils.mo
2940da17dc54330849e344698d2cf73d  usr/share/locale/tr/LC_MESSAGES/findutils.mo
25360400cfa36eaa68f33eaccdd8615b  usr/share/locale/uk/LC_MESSAGES/findutils.mo
789c178a903be7f536cffb6c0c2a3781  usr/share/locale/vi/LC_MESSAGES/findutils.mo
f1630e916ce1bf0647336c335b1b4fd7  usr/share/locale/zh_CN/LC_MESSAGES/findutils.mo
11192422c355a4c9b1422ae06e77f681  usr/share/locale/zh_TW/LC_MESSAGES/findutils.mo
3b11a525cf7a5e5267875da2f1468ded  usr/share/man/man1/find.1.gz
d2c12ccddd7641e2fd435472784da852  usr/share/man/man1/xargs.1.gz
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                .     ..   4 ,nbdkit_linuxdisk_plugin_la-partition-gpt.Plo 4 )nbdkit_linuxdisk_plugin_la-filesystem.Plo    h (nbdkit_linuxdisk_plugin_la-linuxdisk.Plo                                                         +nbdkit_linuxdisk_plugin_la-virtual-disk.Plo                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ޡ  .    4 ..                                           nbdkit_lua_plugin_la-lua.Plo                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      b-     Vo6?Kˊ8M5ۺq[a(hJFRQOwE7`?w޽{TtzU9:i6gCڋ1v%uyRz-7R;e4BcitHkh)B6V"At8:$4Ikn~
J^N)p5;i
)Jsn Mc,S:4LNƭ;q't]Ngg3*mRT(.4mJ!rv<] K?V TBs.|Bsh *;|h	@'x:V;/T*<3g^6Z+&V.g#b%Szj*C2S̰ 'a9o #J[yi ꦒA;,9^U1YcdT/gKygM' ^㝮~x~9[,N3BY)Bs<
WoP[ˮW~HiwP_ioMaKQ^Tr(QU<͍J!!uBHql0RmhgI^=AK"Ke`)H(ڴCOom
(у_Z4N$MVjƼEWWN%Z\{8qt%l8o7P7
pTצK=D$܉J=zQ""U`_T.*nI	+u2&g#I4(6bM#
a[^]/\bTp>вE>˯-VY˼4dvjq>{vn.EH& {q ȐPG|8+,,I乱E`aJ&XI.a^&ޮm^(7`HR.!Xϵ-G(D,Kܗ0w4
f(;/r<l $WI0JD݄˕ 	xE+*񁫇L;l(87^,\?O^1m:pّ۰A+FYX84Lczx`}Nŭ<0]-7N!,h53p+х&'L=F&HP8kNlHhx#1oF޻yP8Q>N8Ke4]<Ifg7'xsZ><ZQͳGi
k]_
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       iwX%4#(EQY],Eӳ*3[4 вVw )ٽ^Mθ>?bjE9*NuVş:,xz7Yݏ$.W"/2NXпwMde>Eq^U:'A3F`F_&G.xͪ0(ϸ(z\븹gEVyU"nxŸ#Zl/ӺӂnV!.Vwzr &/neuworA/ZYt".+^\Vq'Ub=Ռhj*lnӆ_}~%lViC+LhNwX%^Zpg)/xg\n\5~#g<]- g^*:~8iMGbu__r%/M~MaVtcz;=u|u*/V_FU7
KyZU.&?gE~W<|IBSy1
u~\dX)~`.m}h'gy,]eLSL7X.c|zcӽ̼(gmȪ8|yE&nr
YyoZu^s^CpZh{gP޼
c5|dR..߼~2dLs-fW9=^.iNoϴhk<Λ3o"F<899by2]:p00Kiӛ!-/VB6-OV|Ϋivmcsxaa:_H<,Oʆm&eet+Ȯgt
EG+'ޥSӭ&;
r'.wc;n3t[VqU~	ǍE~SwttmY82}/4{!iR}BGWòMo4RGp?toH^NVr-r "v
Ƀ]t.J$iV569^iNҁoӛ4/-y\1ޔWl7ysK/>\_eOiJ@BH
$8<r gPwÃ]^n4|(f[*a2;YS&BJ޶IJ`Y(2RS;Y'֙,hOiQxi8
Bf)ZMh~vf/$(:{G#2}ZH0C@: Ef>_Sl"K`Eɂf5ID2MN%<[~NRgzMyHa#h8>>SænZt4Hzŉz-,fӽ[hʧi/MO9 	~YU{M"bu{`pxܿmCKxA;zi$g9[2#6trU؅OIѧKz5IH/8$h-i#zZp|Vចf|=N$~¦
G8D0<IC&VRD#'v؃"hfyzSлt>_ט.Vn^@+I׆E*6yf=YL矺4J92x9lg.Y[<1l˲Q.T(Fv^ZdIE7;\U}d6LdMSKm6P}|-#if9-m6!yo~_|Ӌ;go?t^'⎧QNCSUj@gzdޯs^_ul(bo6fԺR,E-vhH*@<^6F,HFz)ow'56fT;@ϣڷoN.;<?tA?G60Z߾<"/HWCSKO|cm7ݟ:2|8FnEWe7tRG*NjrǺ|ucGS]"?Y8#Aw/ƦSSS_=TJ$_r򰖋\n"m8xx`t4M{vYlɪʧR'?tke|r?;?kh<8!m9]ؕmGt#e1
+Ч")Cdo[8Xr|0:g6j<ɽy/~v-f5uDMdN䧷pݲ
YgQ\.EXR!#mXmGsЯqG}:{dWnɊJ<ZNR2Sȋ6I_. $|gc3DEvss`T2R,M;,lV
,s.PS}gZћ*)'án(7ḭN븐Q{ n`R˅d,-ꈇN)JXwZZiJ|
;,{-,U%rw//oum%"Y#[5X!&E
'!$+LC!]d%l07dlZdu6k531Vzե,| .3g/~(W|+K
SZĊgS:y)`ѻɧ+~yWoñ";1ǅk{^8ME(ltWAoch()<O$/+L-=kzQț¢TdW/kd7Fڟw\x+RMKrꀶjڼ-Hg^''1D52g|dG)4
Zz.baaxEfxIɑLbt&RWƱͺEy,?sN"7$ɚ/x΃7q8\edVR*4];nT-o(wkt*;L<)Kܠ׳'Ȃ'KD~cޥ2EE]=d	nLޭK24#_IZXdri$Y a':xJ:omsd)Жg]u62x_;l8BW,>N/yU<%J?eMgk GL+I
ASJ2hq\ѧH10PzMWr}_B9A!iN#ɐOnSI:/kZ>>D#9-MUd^q,]w}^#G]B1}!rǗE͹D1-U
vDK3jzn9[4!J	0ece{T;L  +"nt7j$!j=Y4x`Fi4*2bNg&d+8~[uc7#wVbUWKNdm68p:z$7L&ΛwC"VO_O]E^:[䣃"BN)9d	1AssFbF,DkGdl8Esh*\Bܣ5m`t4zjX7q=KjJ=NB}l(Hйm4UߖbeSǈ1.%V+9' GI)0>}!K$hk"Q!7o8f9BÎfk:ƍ
On~?w4k_<zteȣCb0#DKIU~o>`os]ic.`YRB44`KSdpX3cyнn s *:S?
KD#"v	@7ےnX㡝XjVki !`.Z<lx
B%+*9Mr:Uv65ެUal«+8"iUXy$.n.X/g7R-Oڜ"xrsf:F3cC#X\Ⱥ~hhDh;w$Ie.~+|.ԽSW3yҕG*h=oqKT7E|qL$}"53yh>wwDv#ӢN&8Mv7%/OD֬<dwwi
C3:%/&N5N7ҼMU~cltqo)Bl53+V
'ලY?]<O$L{D%C+*jn}7 du0G+6rjD?5 AFj,	`ݭ!kgo(1/لWۙeE		Aʬߑ/:0FpOVj˗/{w`-{q.%n~<I-riNPUDY1S<r(2sxgoJΧ3e8:$<JU0 nءħ0.^qgU83%{QD>yܨDus&
ʹƫ0V@}󖄵`2sh2-sIdxRv&[`s~xtLh^qxFv-Hى݃y
D I>KgۂfOЖ
e(vzh<%Ȯ4g*9C)ip-zd$ՊeEb##D Q_<d&\k
EB~Xl'8m:[޿C~,
5H0H/E_\B#yMg?%PhV!o]¾;u-bóxI(S3~P.5#JYK4~Q
@Ta<^:Y3rddڃdL;AsǙ^^&|k:&ϭ-܌OINitdVȘVxꓺđ7my6
}]81%߽
<eZ}:	?F6l_)IaP;I WǐGit[h5:jH|3uBiL`Iя8v XiZDuOq=AǪ^TKBEoʖ/jٳ0L5}CD^5's=HdtJ{Q$lWl/6^Lo#a65M7hAiV! r:]U"VxG@yC$Dk7>Q{th](.')I^U<?޲|2z|}E{d&ZfwiJ?^qSA~UvE~AHj$dygߥLOv%P%$+D'8͈3Air׽紭S)RS a?d;l`g36ϰRB^]&!{ќ=LIF/Fu%7xG w/A1AZJC@Ds0'i*d; bvT-:pH}>H<e_ѕE"r:>?ڧ4?\xkd$C(|Uzb8:Ua
GG㾸r$n^M, $)nAbg4 GGSB&r f9j3Q<#/ӂtsO[O69}anwǇǧՒԔ|x3֭f(z%zSי0Јd3;GtgG	>I8Q
g]GOaع堿tXܧqvOsQ9Oi؆xzjS\-h9M̾8
lqbdt+_zׯ}kJh"w?şCE-}2JŎZk9r5??98??''`Oȿ/Y(>{qrЭA|ph?>*;z~/W
`4vſ_MZI˗^[]_GÃx<c|p1E?z	::^nMejgYgAuq			GdCv\tѾhhl$R_8(EfEebQֹ;}%ixۻWWo8B-if5{huq`JGͤ8tl+}C6ZER.NpڄE<3kZɭh\u&IMbNȊ/v
J1Vvcǥ*#W7L*&k[4a };|]y~UYlc̱@Z΀>0_|ucD	Aɱ+(@ \Ew`
.dMh}1hprhmjz)ctz4<k%I'
?ޔ}vQ~KE/>#C|?(66Ã
45*8A4ټ#8s@aܢnU/h&ӧwŁ5[*S-cI:CAY*
Y^k,.|ppL/+qj=ѓ6ͪ~gm˅ 0J1q_"v9ϖ
褱77<y^,v-c~~Z~#)Ȁqr=í6JNB?Zň%#JEWS@lȔ#ٮpG쟪We;w=~zሎNח/%v:iJҔ70!]2qh}N4DcsTK=7yc$
{gEp![	G#ksr0o4?:O@'jˇ6TYE<_O=}6iꦂV "|q	,^\SAEѣdxw.\Y}$1͕:CP<s
;('`<>loѳn:ʦ`+B
}
ae"=ӸC·e}5Kpds楥íƈWdb$0Qp lOf	h6vf+nK~^cz>ܕHE7dff:F[jKLbHMSэ	*ԃ_Z6JۇȲANF4A`6X}g9-h~
ߺ#aStKoX fԶV . 3?Oޏ
Gl3m̜y2tNssN)
~jd&,t
C`@ь?Wi>Qy\ر>J^}
 hܪ{jO!m&~l$U,ԚV@ G)6;DB2"4D~ovw"Q2LHVP=Ir[X
3
LWjBs~"f?^bA
,%uU^%J%(KA<bɪ=WEK>WMvms)I3TrhcͲu"oH!y׷R	%ɲGo(_/,	W%)v$<lB"]_x-T
ga <e% SSŁQ`,QUaŧl܆֖x6ᐇik=t;qmAaa&Z+Uޜo51=՟0Gq^ʔNLx>tD0\*	E"gsi
'uv.o:,:YûҌyԵ&YK_OFE_OA~Yr-{kmVOfxDϠ`\9۷c2	ӢLB%1\k</?S80
bncms//DQǃd8V,񜭀ӵs*1"M[C77䡩dЫ=8fzj_2ϴڍ1$IܫN	ZvQR+S.S_hʥˤ,O7uei9M(5/םаȰG"&d:d?"%[MoiO0@yުwO_!9thtd+=nP~Χк#?:Kgz5`꬙+2-?psm:k8<N_0c	(3-^`|L[׽7,9=0`x'xW*+O	[@](8\d+W7/Kk$_-UaۮJtp<)*|uN6-;R/ű<]џ=q0GvR<'z`6`BC)uIt|]#
#UݸKoʀe?
jW%fn7
㏐,1z-ZS5ZR/&!WuɪN{&|+fSP(sRjD(DbJP~4w+kmebuA0:9`.Յ3įBaRK'~߽_Yx<QCY
ٹdRiZ0lueH'ۉB3ZNOOk ?xuU^aysԓ׻BgΣY4NTvb!En&iI8DKōxHE#<#wGhF#JAShXun'P@t!E9[Iݱ
Q6ǬX`aUEصZYSV͌$X+KӥZ !$bE8}WEkVR#ZWU
Iһ
¹8Zr13%=b [VC(p"2
fae[x~l$X
96yLI"@4 	]@W$ˆ8/MmD>!DKA|[9:=cOj-7l$3	hxPBU_XjrNg6D!o^_OCO!l`J~sGAZ;M~MF~K,MpdpOA77\(/JH8ʹ>|jʻ&|@pi:jsS0uFɺ_Ld˶8BߍcT%Nꆤc%{cfd 00q
\Lw>#wdkzE;`]DCB~ѱ6.	٢2!~ưE^$[<ʊ{ZS^˞jTV!z
&u׷UbVw.0D+/W7iNS2g!>yE=f(pNncvw((%8S~vQ\+I`;OSʛeU2&(:Un 5j(=r$1aE'}o$"I UTP%,GZC~_KƂ4Z-)eVO~)FQPS'pw19k͏iF-#S@V</fӫk;s+;UQXd6,xY`{%e܇T~:zc78r>w=Ht?21
ΰ>G'G㩋˝7]tQB6lVVd2hD'Zl4Ф]|]<(J4/vsQS%(fxOB%?~̌4*ٔx6mp@nh~+hAY
<BPeqxqSM\ġ;asP)o7R."s*Ky-	[H'$-Y|`=jUEmKyTFhXG56x8~  W0_HW
30DPU[	gj^3:ʒh'68|E]Uk8_Mg]$rYcˌ+pW0K?sy2NFx[_a(xw$.78&к<$	^t~G<>kұ8;ߡ1HqA,|NhaEǍYG~X#G"a[F#w	֗/eXAr#x(ILad*]
b%!HO~\_K2آ,6&JϥYS痿ɯǸ[m5xVLLuFG3й7sbVuz.	,#Vk¼6~
0wǑg_<><>gK"\ĆuΉϙ̏/ǇׇlK3s;dq*HfH8$̺4Jg;y|)1tһ	8+n(y
ܕӛUCd2ñO
%Ð O`XZ\^Aۜ6+lڲKF8>A)ۿ L5}GRC&xf3Xy,/E.BAd=v/K-:@0qgv;Hd;g`u|㴠cCŪ^V
M9ˮlFGe^ ɴd1CeWhH@+~}YEFw\maO'!f"G㴝ds}=)~JO`RD3q!ogO8,n_m,AIWD6&(T46~?Xo
]lGc=HqqwZpߖUʃi
HT/c3-,+0K2	Ks0p+,2R՜	N
:Le)5R;=D`|"%D,* XWXd?].a߭j*l
S4]B4-BǕHؓIb
 z#6A>	Aa0J"PGUC\Y%Ա{`Q(6է:&:mG@+1ua0A-i?i~(z!~vlΌKsVr?(x=v<q8p3={M׭dw+n	;y>VSf"p}fZQDBQOsqtxtQ2b̔jr,!}%A93/T |fBg&?26Ǒe`mHCZoyZH-ƗG\O/zE/:8DuFVէƓڄ-_>O~
x ZZ6rh
2)5Ƹ1
ťGǊȇ>n#o>z%9rk W(洭Rٙ	4G\JJQ
e+H2P7p@y6ջ
 `%C
TNj2?<⠎И5ɦse񇸊C/o\$b8zb=1~ψ
HF! R^bɡY[Rذ"ws ==HySES;B'y$$k$Mm|bEu%n6]"8!<e/~)*oBLuiSbU-8&wI02Ï
!{;&«!$u]QtnA_ZD,η
S޺,k.b@?֏8
GhDE̘E&|JK eEb>6|yD4KxVM[XJ(Un% e%DV":5Wύ}m	d SZسܯCi!Mv櫰{R+͵ڭ<xxz#l#Fx2y9x Sy@đ u\QkrA%KH|]MXDnw3ڍvl=цVҒg#$I&qZ5E4d1]I(PAf=ΣYȞKg钆16Ќv
e;hʹtĚs$}*k%ⴘZMzQ+6ޘOrV~(|3Ѭ_HRUF%\X$مZd]=8S	'FN
V`u o-PZUTH4j._#}/,+:	o۩EJN
Lh%oUH
T>繻3ށ9TNa
tN@QAܵA[A`CU4;]Ema=`@,m4RxI;^w!b"mT?\$̮N'硏X[RQ̔׍ڼMERDZ']W$*9Z$MA(X.f_8=ݬfJwv#<9#Zi@n=>ZO
&y3RM`jǻc[A4aVk!,5!,V\-6=f{:N*(r-XΡGp788:bN66Zع&i0ԽȢ)ޢ*FDOid_&,8H~/s'uڻW !Gx}h/ b"[TNaHqv^>X
GG0pE\Coi&c5Pu)+ڶkX[bDF:dz'H!|oM. ԊQum)lb\t]*,2i> Lo*B`|eJ_zz8@&|dx,1Uq%]-Iη-PfY+:TTFzEL^G??s={C˖k5N!Pk8& 3в*=M3s}C4챚+|ѾD2*]ehW44(qhKK16[3ih9<UL..lə\kr;l^wOr0kTZ?:ϵ&R$b7CƵVFgzMFʼ2+-n)r6ڎz!wCY%|xyI7s']~pчVOVr/˫u|l"mJAk󶙑C_Iٿخ)QkOpp摖gO~Vﭖ2{dx|o4bpIH&0%fVZʾN?.,Ծ32Ml*5/ݓ)`tjJVDW/iü!]͡ .*9Nv,Һy]]TgR4	t-iYrsq]Rwhlc0/m; 6-d(J\PiU'd(!YBeqQ-	ί-"ǆ1Ŋ3ӏXSWuy\79JW|KS,7Ggi1x4ڟWF53 =[:uN 6FAW?Rx8&M7冪yjM>-$1+Kp8un@,nǫMo;qc
m5)ҽVQqL9[̓1N/kmH`(a82~7WH+Qf1
 e |
a2?f2xeZ	.-E~yPR"N/f-Yww8	^A⽯xar7tk
<R~=;ˍIyn"9/BLID
PF<I}uuN~;'pp8Uﮮҍ<Cdv4oZ׮X](ML}tK@ /5ʺN$|aάੌ|\Y5 RO|y~?GXboOfѷfp49'҅Di2MqjT9ñC5MA]_'#ohKzJoj3p}︆ϟB_K5+G18F,rMs+]~L)nycfY@
d=>B9F+Ùɱ6ZӮ2m0	0aA=
"=Rha㘿,]V 7L7Gjpk"C<G4
-#rt4ҼR{An}GõA(XR:IRm76X<ux㢠h-K瑼
ۖ|8q`$zd4+S[v]B1vdH|tw*=;Yu%o.c_!9;xgr`'1f&~<v/4'LI/Gy
̛Hu
!YGb{AwQҮ6[fOKR&l@ֻ$[d+::\WL]{j)G9jXB nuB蒙qDcp"i@ K?lZ'
无SWVnowzk6FޥvWPBא=kF?_^}x۝,@^1~0OdHVܮYKq.(V~K˗NK}\E:ԩeJfT#]p$
X{1+.2Dˎ2zщA\QTwdTZ^Ƃ)X&#%	Kf$,#}xxS:RIo*b 9jĸ@Rf'{nkaQ?eY?8L-s:fp+p4g,HqPNZ!X>	`^X0Rӗ}79/18y4lJOjFqMT%S9t`HC`
F-8	>f_"U<TZ
u5fd]oQ9ɚ{)
Y@dܴnLZ?z{`dyǈrjNM&͓T0;R̨%reBP0^A,K%8Sb&"CxO9ex9"\QOYKNGq$vڲ1OPcG1TC«\(1}&"M\9(3ORh_fG04S98a6gJ>8=.Zl4A[i	=\ [FSi<>ȗa8 BgGjZ*jmV*rtBR`ikb7)~PY`' ĭ@aBÁՠ"b'Ƥʅ!d*pl6Pssq*v#cok
WKaGoqR!~X6v̚̗%n-Z(+.=ot`<[_`y KX2؀A')˅F _{~ddp{lg(%~}k=TYC#5Ui*ea8';iz؉J'ή^{1JB#5(4d\7rozo߼x_x^r?a 6o2>s2o4H@ͱy=]	CL &rX{Hceh+bHϾxWo??;gzUθVEj'MC3ue3okaS$T/ivXA_d4YUnYy=vSPmkb$_ӽ7"TQa!f<޺1Ҿ$bVg=i&3qg8:O&/EؙVP0YRi2O}{ZY R*c"](0W ]o+5v%}-M ? ] xKn
hlj֨!8Au
ke bS[13ۙSߞ:Pw-%$].i(Lɾv){hRDhX;,d D=~<J$[ct&ivLk7:aE\,>?oBS5%T)nZ`\镎򔭍$ڜ
ʫ1&)]fB*.x2qns b"Kn׵_2oߩђK7PEAEFy6;w5؀.tuכ*^bw2n@":5
W$G}Ϗ1Ӗ!R%DyZk]XmਨfM-J_L85BAg]Gpx`Ӯ]΄7JJow[XA,Y'xDR ZiJ*N_3f;ErE<IzJ
de$!X~eL@&q6UM3!ysX@asIB5De=ɢy? l@g}3F<<Wn:iA.C$|v@5>p8(	K-PNRjݠR-lfv甌O"RuND($$GN1w+BAx16}`ebhl#Z_6,L7iYWB[?<m)q+hE ՘8lRW(I-nZZ[6佹 txc{/Da4j.˛n6 YUf8@7C0mߊ!#]+mHWqa<;Fe	Qk5BuQ/dW,QBV₾
b۽he8`Tцm];s9f(3$uQ4<	- 6{ꐴ}^`\ΙS %D!x"3iv2O<t;{We~E7X6 XxaDu&EֳfH|Q^jcIK}幯\<3DQ^v,v.pd
^EUʴ9aWn	
7Z0WU#TS#W%b_ΊK.2Bd6?]#ijzoV^c:t%Zsp'X
#d҈+9M1HDD j7ұ;=ޕN :PPRlOmǷESG
zJSbl \Xu+LjY{<e9呞M(v3]¹Ua/j-i!
tHɝ]<Sq	TvSX/p<[6!B^P#/#<ZZ@fo\7pmg֊CX{ l=AC;+WJ];N<I.D>	y:*<<'4-:ki\"q
g{DlGDTh y-[2YmRpX0Ed"\BVOY.dAdg-9PܵP9l*jp
̅C& =IDi~?OI͚	2ǩ3P,Nĵ-tR*yp"ݵ̵ٌtw5tsX=wr	&o4?=qVZjA]M|%ygWsھ;EPIˤ^:7E\,Ie$n3抒JbHy=F[PFeQ]='7r7#
|`kHL@?23.:ЃгgNAHcrڗ%(	:?1sQVt$n^I }ΉT 9K
NEé@VK
s6+xT/iaR5~H^
ު`j%Sej14v|>.bI.3&\z5ItuP(v[1戕zHi~{mb?﫣8XXugp><
>{~%8?}?oooJy:(A>0a\Eneg7d[VlYV~外W\6
<?]O1KWM~.7g-Į#heόϏuW6ة	){γϯ
׶g"	5>{D%*/%_G' ^egX{7ZEaCn;OI|㿧wshY%gϻE"<* BiZAc\¡<nym2_r6̧Xцqdo~!ѬVBnWZB'ڤw
DݝR#B;i:ʭ9Zd/HG̴\RsO;HRs<u?{
c5MpoyBfA^r*]ױAxt<:o[ZdcVLv1L&3LwKyP*j Юd ax;.aemZLD#my-
jfSF}RtdJsZ6TWYB8:2vUAǙQZBr3z](M,q2Rʙ ma4F5ͷHƎFO#wcv9X@BI).yɄdaIGp1w
pgi	TF]VJzPzTFχ."*j3gb[?	CN=¢m(Xx<F vATd0tSb/ՁS01ra뉵O[MjG;t+_"HਸP`zHa+4S1=E0bWܲ9xց@"{NuwAZʩ+NWI:BBt%#8zfAwXM̭x:Ai"iFdkg+deMƇoqQ54j:ʸV!avD<7B)~Yכ9KMJLo;ocmWPkZ0Rgu{u "Џw֧j4>>F3rV*t6pj16{爬SĻGIvPm~V,]E?8rժ09'	(`jVɉuff,OU{A%&e:O>Glbi3H03|O;bh|l	"n(DMOmJ|2QutlgK{(;50@k&C9
BQl0,Ֆ+(..:zsI/j-u ,&G@
	HΈ^7ײ]h,,M%m}F< PRlztx`{$p
H3Fr%+;vHv]fUY(
1B&WҾtTէe.|&4U})uhyڄ#fk|X,%TEd6Ju5ީ]>K0_N'(VdSƹMeA"d|viUpUԎF:Y3#ŶTԿ3@zIΔ+p%vv3Y)O7?EvbʚF9:Nr*kEmQ0
a~{%o>'u]$,&xtϰ'']-v(TZo
h1ےJw**	 Q\׎$Q'B$t[V	n5܍
E$NcӉOTѪ,_hp+EFpUs;3rawewʲOT4e/ݲuiv
xUI߂V!}l |juЂۊD-UG>}_iKJ7ϋGܚ$nQUGzlOymSU耉/G4$b?܆ `qwZ.!"9le*ufY*(#VtZf̟g)מnHQ;cQ"NAMZ
69gSQt<ǑKn3 xj"),{מE & ]\)hRÖ$(Mk3&t+#ijfr.
s!Z">?,b!0|hYAe  l;tܗ.,j)AoD	ᴊ @o3v&kɾ<߯P[rMmISrȿ=qw箳wvh.ڻ&P# _}P>RjӉtbq͛:UnK'HVNDu^Ybrڕ+yFqjS= eJ0t-q3JeQ"t|MJ՞7ԍG*^9:vu@JUH|[j	|l\8DRU xJ\㢠3:+*b=
B-c!%jS%(teKWR#r/a#r|<A
b}Y;\hi6>ACњ0VQڜ;7Ɋed>f"h;	:InƸOFݯ_8e@Ikd?OeE&
'ŖXeX]?G7s @{dw,th!6iz(aQ*Yu|
m83dRAU4w
m;T578 d<484JsF$+sNo(hoF2]e*@x:q }@WY"ݞJᝉ0c}5VE#~sk#xTW1ϷoGūa#na 5ES$LXY9N	1#ӢU?f)ZpĐI;m!$+s`PجF'}謅
⽬ݑWN!fN6]x ݍve7:t,@-89poy*	i<_L]E}Vūiǳۀ#ymӷ*QAmh5 ww9UvEOYuUe	Тݳd&ήprMjqe",?-9~rOZNrmaԀ$pdFC"PE66}4P6RtzoiJg4)8awFǺb2("	Aʹbc 7G3.~.|ĞXk.^rU3;}.UC<rOI,^L֮PHZ½5hܮpk F!0iԦHH4s%a8A@x`lX̬82^7sG!!"@jX)LN!A_IVU*m(/-KёGqbjz%JBca(>gD8T9Z(h+6>=gӛ?(#>Ղ1D>cVxujS:ܴOTΘZ]^2K'Jr;#6	L[7Ԭn'RGn%NJc͋7sjquVfQ`Rmq=i72>efȈG>[G&b,5:jL{z~yRbh{~20%\/+4N7$)$ ?
\6g FΛ{- Z*7Aȣ~bք[aǅWVu{pۧz*]Y8i|c#N*I!F-8=:2dtz߰m%DJ_6dWO=צJ'dPg%;kIn
:ÀfKsIOڵAcN
GBJN(pqx#m1V` *馿˹Q5py]awۘK1f&D~B(vk7f9@t4׈@%'Iga+XMsJ	9ĽPEJDXvoM%Y%R5|;$\ #>qE#Mp*Ͷӷpt9,Tm8R&retP'#L[āvҎql6Ϊח	
&g\	جΥM(E=f(J#+n[ҕ[F-f/lcDʆ^L0meǥef>mZN_Pek*~zk[Xa{x;&ȇϊGeO[3nmRZ=z$$=[
B4
p'hn@xQR@gi嫫&eRԅr ӺiyÁHJpjCmKc
8`m,FsL+@ϒݨJp$봶Q5aӝ@yp	@eZ1MhQ hV:$u .,h XP-p[X9立lv3T}OByakۍ2^ZKw-iӝ o+7M|OI~*U.
0>-"FL/!V"8i⬪Iyt+r U̼BfuzCprcͷhWAFjB[]*}Zve`ثmElw+jms,S≼)[yv'k*MIx$WZrU릋v g3v۹Iz<$[(3]PqeQ+p|]wpa]ΦK};hz{Ǔb}Y6RrI9(k@	b<cesN
u\CՅOȷh
؜C˶|y!ǟեEFAF&w96nT5q(VۆlkQ*rc0#AuQOmR=Z .K;1j%S3"c՝UUorCWQq?W(ȉvުG+wz]W'z,h+Se[IJTPG6?ku&o2{vE1IO>4KvC}]-G:qU -B$˘2D|#|\*!!Gu_zW\|W>;1J+h4z+X=!i@QY K:k/v$Zi
dk6McƉ6M$w	#.Em}oc膽HWL5bl7k
ztiBt]CFdLe=#mTwFx
\{Y6C8!F2Q.!dbT7
bM>1.6O
#n[ת9'0"*${7ɋ?]G\`YlIT,Ζ u%	tM,E$S<gNYFm脟Zj{'%K+ј߾<|Jcηd)+S S&S<)?T~d\GHQ[i@o{
~PÉ$؛j/&ҵ4ںt=o]ne{v4q	al. f'XgI}B-:5v
̇0j*8ҢTW蚹<D̅QEo46;ۄH-[Alł9`C#YNz[f.XWi#4*G*jN	}fzNkDsN5
vwe{W*Nz
#r,w=GP#򴩙`w]t]Lk&V8oUQf:#^kԅ* >Ҵn{Ezz\'-j`~q%
I3 Y6a<6#]tѴqwUgv,b(9HOJ+X`Y+\"i]tٲ\g2_H¿hTx} XD3G h\ʞ+=&㏌wn&[.+|BMƻj'gdxgDzF7
zG 7FDEzbg*sߦd^Fu)7W$G;kčt
xǩ:/N?9rLۼ'd=xa\KAA;RPR`>4j]A4
f ־e|2b@mh<0T[2*)g({s
Bך\2 nԯ/|Н9v׉?XoٜdF-Є8O዆
}+6LȀ h9*wsg!۟ZK ԑ@yc@Q۝gRvX qfX+mTi8 iBo6jG5֦Ǐ71Wc[x@njp$k^qѠ8BFH3.Jܑ|@IdU?O
cdx	r2HRJme%B}0I.ZW>д;z|9ЅjGv5WA}jzSE	Pcԯ|(^>ZCOꃂWv4Ԗ_0-?ZRz-k{vpr(ǇØ_K@܁޹ku;6P!'TE*v۷91efׂ2γB2PlVUޙ,`ݤwј)wW1ZХM(uhEi{m0#eI>eZd除$c~oiJt=}UKކ>{0XrLITLKzjd*did==
%Do..\Uذ"-Eq신y[sPlE|62mu۪UaOׇM`C@$j=9\ uÜm@x*%)$k4	j'h_F9vht*d
˵ _ DǬQA>!m Rb7x˚TN2_q/'T!(=o
.Z!cgЭ&]
S  ^mf0J6ھlI^ߢQRN2]weL5k>?J-boQ*FD\YF@HP&Ich$q-mփPV15ӋON%w0S_Y@ȱ}A(XFiJ&
Ņ
ɮ \":o2{rd؍%=qBZSSy]tgأ;ݒ
9-7Tb`zjt?ɽ&C.ܰ	-ȥϭ$8c=\ɿhu:zI	]#KJ#AF1A}Y*7	)(}sn2Ɠ۴%H0c=hqƥ@R͌,vޅ
N:xɶO\˲RBT
]]`K˷l\I+KkMH	W//^Uv)4] ]bX
z;xBi3tI>4^\ !_|fV0T ϊ5f~hE$' s&5=8;3<"ڍ19?/@X@Y[hYCDe D{l)y yڋ;p$b`apyMJU?2㫆DN%]kl޼E{u2Wr4L21c跜?U-TkcOO8ip\cz1)R\bbyd uZ)- l7IvO٘")}ZPgYԔq#pm8\ oI9Oʉm g`.[EH!>_p|=Bl|%(#.6n n,R- 
BMMՔY@_kMdQB 2A۠utG=]`"\?6YiUAӭVBCr>YOlNd5ܼd*Pڠ;zl$̍jklH"E):o%>Vps$FqvOAϹD<|r

7{A%~Y93F}/X\=m!LtGmbl^(x7I2\q>*rni8jB`1ݙEjL9j pv噚	ܣe3Z>M9#Cnw7YJ;)tiZ](.kP݂%X̓ $ԿAXiJ]VYɫ
2&K3"ڄ$zU<(2*E#e[Om|:
ό3o79mE`;9U"vMÍО s\-U2@jLFVNmRL`OjjVFH4J-ᗂnSϐtВ,_)SZٲ:n|rr,w'7L큟Sæb
9PAeN2G9}Z6N(U#ek	.=
<p&X6߱Ig9RBvT3\<lǠ5wdcb0=IMZچ(Q9ӸXBn[3WCMta?1P^L_P*%387sѾƁ1	+HË|RVm?|qUtN̾?1{2`	&v֜e5IȤV[g|8/̊Bc^?].y6eݬ)L^F*)S`>b*Uq"7O;降*C=h/#G<rTM$!	+XvF,\fQ#
8WHz5RZ=fױZYo߸j|B@TXڛռ>Si&ڑ2ZOD1hv||J#Oo9)R0R4$].@.q9e
48$q/,-181ʖݧh6@aqdɛ*Y0[RK'+87*5lO؝ZIj2*}
.zVjNlvӳ:N1#3 iIYOJOIGNvIC+.2[MLnY3q&]38)${mԻ"R9?ǳdvo7lzFAԵ,f?5(r۷ҌD0oE7,
	ۺx 39NHb
r
y݊hiPY6JR
r[+u⛭ok=Gl|\j4>$[D@!3mv󲕭8AM~b0Hƃ',
p3AABuWJGn_+<ɑr'6	ށVVR_}a&$8˸`N&[d1R(W4\=eF$tmtguY'{?Zla2J&GfDV&=^(sOGƷeij
ZUox 7Bk	5SV%pl±i(
Ў|BOI!D8ԬK7e٪a=kZli,
dVK{jVR:>jq[P2t,ۜQR")9H/aO3KTήb%2T.'J
n`	:
㦁^>L[U*e/R֏ÿ<w*%>~0}'> űnwd2Rh]'bKp l|
_-ǶeSgYI_Xsk

%+PEHbʻ84?PvEgOڻ]~6Ylq0UpBΆ-O>xam}?IV#,^Mw.MofYuu?ϲ_V7{J׵$7(9]{dM|t-_]<W߆H\gs

6
͆
`
Wo_lۼ.RP7y_`}KvVi+	Oߝsen~aKVb{d$oH%a<1j1 ($~s~nJC&{E=i/^IOŎn:}KZRcYoX>
{T,֑ɾyXF"z6fp̱K1Fh {*AosƊ*M?#6Ɩ^^
t:2Ό yUG@B#<kM)=^~~Gc%<kٮ7m-K|qWor}u.ed	#K|!{]Ӭ#n
M4+{$i)?,ܯK$\y i$ո:]SH#Gv>9s")-3WyBy
C<c[&n{Oj
v`<Յ7EKsh=h4 ?k+4cM\ܚ
%n#B
	n45dZ%	3&6c)NmuTgxu sx"K̄
$p4kZ0x;א8|
}q2~H<)F {g4
Ҏg7xZyAK
Wr8*/U[~-	Ӵ?,=k+怮R	S!X80.<Rn.׍aJ
lKtIa 4!mOҥ6j4uS	-íⶳR="֝
cBϝmD%~0nKIIKl-h]p3pqSFw܏ˬSfuϭvKJHIe+lJ^yVgQft˞*ԓCmSWQklt70Ҥ>MعJ*<i
_ͳH1UlN
_>0W-DVYGŃ2t"M=fɣ.-R6u6-v݅r25hY$W6a	+{sy(+0+x)w _C5
VɽMUr]̛~󄮐L8D23z)is9߸?5Lhpmcun&-O8ǆ{Gz#HG\
I<3RԈƓ̀}ҵ&Տdڟ	OP=}oOYK΋dEVdtxa<Q=eҔ	$_n:LFGc5ۋf{ǧ̣EONNqBX'<鲌dc+5C8*K;AwΆu,כ?_~AK}s|dUtM73hvٛp,4g>I7z~Na*,cqnjA$-QAնJ$QJdyǤ@Ux={Qr)ηu/Dl4UcU3"m9G>$jNR
ޢhP\mL QTuT2D
h˪G"
ԳGh9G*^*{'@7o<|QkG-93~XlKnY%>;1۳LKn#K\,)(O J,T=)D.YZk|#*[of:4ީcWTWZZ(&Z+n3<sڲC͸7|q<i}&♅MZJN3ϗN<b<!f{Awj@8:b5F-n3<g*XxމfM,Fgo/,[9Yy(}:K$$-Olщ2$YYhر,YZ@=~۟](F>TAAF<>Gy3m7yߵ1JuXFH0*y v=RV(f#.oʘ:gdD+.hCҏEcVE!{*~
F $&Wac_
nk%7_
_
CMzW\:nriN"	ޓ%i[ǻY'^D&L96C?ق3J>Egۜ
yW"Onmtк0D^fb2#R}A 0uѝo_U|Yvca&n!_Z;+ړb|.( Lޕ!P(:#.x01@^9eA]\BpYn/``c=5s$abE\@G+o~/@G&cca,N[zcH	r/̉&1sQE!ہuiG}"~
G[BF+i]3s?ao:ȃ),Z
X                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Xrܸ}W "v8cˮTg#ٲK)VYre
 	t$a]e">٩bj-g26hY[uKeKٺBE-;ja!W|
"]ts/ٳS\R+ẏJBw8+]źg?ڕ20IUѹS4{V6Rnt<aH'CuGd:\ReiHjcfpk-s n-Xsޚ{--њLǋ7l1IZ}El40WzjC1onϮXԴCF AQ !?iܸ݁^{k$ҭɜF+]f"RxJh<ES(TT>1x6z2_Z\( 
[x$|drm@!狳.a7ׅ}!aNjGMOJi]{ٲ8-ھA)j$p"HBoTT<e0UG2FTJFU)
oM~߸Z lh#TT{\碶zoVw6j̝n7ɘTPĕ=<#4NXNNsًt{&qQ,<lKT`]SHQҢՑJjI.PpS?3()im⠼^n#jtaTKNT$J,#?3UARmfU!n
xms샧
aٚ&pýirԮٻI LAUf ?DZxy 	Z87c=Ȭ7҄U`1ۋwg_n;\j{7PR[wC125cMAX=u\*5Pƽ4 C-<u
-x618KoƑDB_Xxh+ChPd+`F3Dt0T@БӿȕMA*7l3#ń}l|0R=SEBͷY;gjȍ)5rLdќedWB?PlQ`SEt
衦a7
tHLE'E|F+x|8ʓ^-[S=d)ᚹIDLQO
Rґ}>$`MƔ\tzoSV됥hD-3E[
dpuKB2|9&]jό\ z%& v鑑Q3^RM#*OZÊΕh=0(ZCd	n%(7>7rmR`87fsGfr7
!nȧ@:txdk@JXhp<(ᵻIН{ao)nGlxx9_.^T4ȋtu)]I"?)ZDjb1_k&Ř[Q@Ϩ;G]|zo֡$1I:6ݜ@jF=-mބLkAqP  \GLFjUDζfDmZQ	k|wINt61=}4
X2!KSܖM\>P(8Wa<ATἯjj=5X>Ǥ-jEHbj%
Ʉ ìU
}^SkdhQlYOR!^:nZ%r:~MC%0vh VNd(wqDSE%:
&,Pn[}#7,Y;X(q\gՆ
")rA҈FgimBymB qwj51dYqjS7P7L|UXCب)--qiuGFHT7w(ydȮ>M-#̉d՞O]foZF݆=
DuRRmM@Z,U+c0 m$&[!,Rd*̉=?=
oZí-eaP8<)]p]YVakVW
`DgehI<?uؔ1>;=Mo~"[@5&iJ[d?Dq:;DYL6)8+xӧ.Zu~ݰoǃjrOpjz|ZP${`]ȝ_RT6MڞiLp8Z0n}ת9
~Kݗ0&J9}M'}OAjP R~PQ                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -*-outline-*-
* Internationalization
** updatedb.sh should be internationalized

* man page for frcode
Perhaps a better description in texi pages as well.

* Add option for find to sort output in lexical order for use for updatedb
olarsac@airfrance.fr (Olivier) made the following suggestion:

As I was running thru the code looking for the bug I wondered why the updatedb
has to use sort...
why not add an option to find that sorts the output in lexical order?
my point is:
- sort on a big list is costly (here we do locate on big big file system)
- find may (in theory) sort incrementally very easily by sorting only the current
directory entries before recursion

* Include example of use of updatedb in documentation.
Use something close to the Debian daily cron job.

* Supply example for time range commands for find.

* Test Coverage improvements
 pred_closeparen pred_openparen
 find -delete dir
 find foo -empty where foo is an unreadable directory
 find -printf %i
 find -printf %l
 find -printf %M
 find -printf %u %U
 find -nogroup
 find -nouser
 find -links +400 on a file.
 find -perm : savannah bug 14748
 The close_stdin=1 case of prep_child_for_exec
 find -printf with no argument
 find -regextype with no argument
 find -size with no argument
 find -size 1e6 (invalid)
 find -warn
 find -xdev
 find -type c
 locate or
 locate and
 locate visit_justprint_unquoted
 locate on slocate format db
 locate: the "procdata->count += procdata->c - 256" case
 locate -b
 locate -P -e
 locate -P -E
 locate -S
 locate with limit
 locate with count only, no printing
 locate with $LOCATE_PATH
 loate -0
 locate -w
 locate with regextype
 locate -L
 locate -H
 locate -P
 locate -l
 locate -d -
 locate with a database it cannot open
 xargs escape processing
 xargs -i -n1
 xargs -a
 xargs EOF string on first line
 xargs blank line (state = SPACE)
 xargs parse_num on non-number
 xargs parse_num on a number with trailing junk




Locale-dependent coverage:
 locate: visit_substring_match_nocasefold_narrow



                        --//--
This is used by Emacs' spell checker ispell.el:

LocalWords: xargs updatedb sh lib frcode bigram texi
LocalWords: findutils Debian cron

-----

Copyright (C) 1996-2022 Free Software Foundation, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         W[o6~ϯ8Y"EbithaRJ,"%Tw(^9]`]ǣZ(6X!
<xCjLpшZZ5BqOsP~ż33(PbPINzXB ZHoVly멵\i֭,	/eg)(gT1ܾ&};wzbPd*0AZ$RPv0spkE]
=C|&Q=`8>j]uAsVǀ腚UK"!ȳt?.~׎Б@""HB$|eGn3o?py9'ȋE-W{zOc-pmD#XʀǸ(*'z:.Tݹ\GQg8jplY݆h.,$$qޭ3Y+|΍5kdW.hDM'n
C,|g2Cj,Mx#g<KaCw(SHpLdAB<i5\^_Q7Mg! *MgbRN+Vg$LB&q#qS@P Pv-0mW×8}wi0Q#pZ(̈Sr3Q5*#p+g $.>8?[dit1Jh wKx)υLb5Gﵧ|yu""NvBJ4>Mvg]xdS\B4BAzՓsN2f<
<,aTEqf!O2G4HĄ"@G}6EƸ߱X4Ժk³S;hwV
UsǪk[aGZn\mg}e2	8{=ϟ#6yh\,4:*3<ʀWIeUc3[R
ҰfʺĪX1kDC2I8BA.뼥U+q|6̱j]n=;/ũ܀ЛVaRӠ=VAaP]L;^`
E$U9>䷼(l)6Y,FN=1IdvEG%,4Or<'/mfS5ׇng6Ɖsr/}j*ؑ,38icmoRjp`Oxo	\I  QE$-jȍb7c2rO"LGWlB:y2`U	iQǌ;]Nqex\Gw.q'ު><[u-;$È53_{p>"7J6-vIͰf8M8Fnc:#D{{FO_M                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: findutils
Source: https://ftp.gnu.org/gnu/findutils/

Files: *
Copyright: 1996-2022, Free Software Foundation, Inc.
License: GFDL-NIV-1.3+

Files: GNUmakefile
  Makefile.am
  TODO
  configure.ac
  init.cfg
  maint.mk
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: INSTALL
Copyright: 1994-1996, 1999-2002, 2004-2017, 2020, 2021, Free
License: FSFAP
 Copying and distribution of this file, with or without modification,
 are permitted in any medium without royalty provided the copyright
 notice and this notice are preserved.  This file is offered as-is,
 without warranty of any kind.

Files: README-hacking
Copyright: 1994-2022, Free Software Foundation, Inc.
License: GFDL-NIV-1.3+

Files: build-aux/*
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: build-aux/config.guess
  build-aux/config.sub
Copyright: 1992-2022, Free Software Foundation, Inc.
License: GPL-3+ with Autoconf-data exception
 under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 .
 This program is distributed in the hope that it will be useful, but
 WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 General Public License for more details.
 .
 You should have received a copy of the GNU General Public License
 along with this program; if not, see <https://www.gnu.org/licenses/>.
 .
 As a special exception to the GNU General Public License, if you
 distribute this file as part of a program that contains a
 configuration script generated by Autoconf, you may include it under
 the same distribution terms that you use for the rest of that
 program.  This Exception is an additional permission under section 7
 of the GNU General Public License, version 3 ("GPLv3").

Files: build-aux/config.rpath
Copyright: 1992-2022, Free Software Foundation, Inc.
License: FSFULLR

Files: build-aux/depcomp
  build-aux/mdate-sh
  build-aux/missing
  build-aux/test-driver
  build-aux/ylwrap
Copyright: 1995-2022, Free Software Foundation, Inc.
License: GPL-2+ with Autoconf-data exception
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.
 .
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 .
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 .
 As a special exception to the GNU General Public License, if you
 distribute this file as part of a program that contains a
 configuration script generated by Autoconf, you may include it under
 the same distribution terms that you use for the rest of that program. 

Files: build-aux/gnupload
Copyright: 2004-2022, Free Software Foundation, Inc.
License: GPL-2+

Files: build-aux/install-sh
Copyright: 1994, X Consortium
License: X11
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to
 deal in the Software without restriction, including without limitation the
 rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 sell copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 .
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 .
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
 TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 .
 Except as contained in this notice, the name of the X Consortium shall not
 be used in advertising or otherwise to promote the sale, use or other deal-
 ings in this Software without prior written authorization from the X Consor-
 tium.
 .
 .
 FSF changes to this file are in the public domain.

Files: build-aux/mkinstalldirs
Copyright: Noah Friedman <friedman@prep.ai.mit.edu>
License: public-domain
  blah

Files: debian/*
Copyright: Ian Murdock (before 1996) 1996-2001 Kevin Dalley 2002 Thomas Schoepf 2003-2023 Andreas Metzler
License: GPL-2+

Files: doc/*
Copyright: 1994-2022, Free Software Foundation, Inc.
License: GFDL-NIV-1.3+

Files: doc/Makefile.am
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: find/*
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: find/find.1
Copyright: Copyright (co 1990-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: gl/*
Copyright: 2004, 2009, Free Software Foundation, Inc.
License: GPL with automake exception
 This file is free software, distributed under the terms of the GNU
 General Public License.  As a special exception to the GNU General
 Public License, this file may be distributed as part of a program
 that contains a configuration script generated by Automake, under
 the same distribution terms as the rest of that program.

Files: gl/lib/*
Copyright: 1985, 1987-2022, Free Software Foundation, Inc.
License: LGPL-2.1+

Files: gl/lib/Makefile.am
  gl/lib/areadlinkat.c
  gl/lib/argv-iter.c
  gl/lib/argv-iter.h
  gl/lib/at-func.c
  gl/lib/canonicalize.c
  gl/lib/canonicalize.h
  gl/lib/chdir-long.c
  gl/lib/chdir-long.h
  gl/lib/close-stream.c
  gl/lib/close-stream.h
  gl/lib/closein.c
  gl/lib/closein.h
  gl/lib/creat-safer.c
  gl/lib/cycle-check.c
  gl/lib/cycle-check.h
  gl/lib/dev-ino.h
  gl/lib/dirent--.h
  gl/lib/dirent-safer.h
  gl/lib/dup-safer-flag.c
  gl/lib/dup-safer.c
  gl/lib/faccessat.c
  gl/lib/fcntl--.h
  gl/lib/fcntl-safer.h
  gl/lib/fd-safer-flag.c
  gl/lib/fd-safer.c
  gl/lib/fdopendir.c
  gl/lib/file-set.c
  gl/lib/file-set.h
  gl/lib/fopen-safer.c
  gl/lib/fstatat.c
  gl/lib/fts-cycle.c
  gl/lib/gcc-function-attributes.h
  gl/lib/getcwd.c
  gl/lib/hash-triple-simple.c
  gl/lib/hash-triple.h
  gl/lib/human.c
  gl/lib/human.h
  gl/lib/idcache.h
  gl/lib/mbswidth.c
  gl/lib/mbswidth.h
  gl/lib/mountlist.c
  gl/lib/open-safer.c
  gl/lib/openat-die.c
  gl/lib/openat-priv.h
  gl/lib/openat-proc.c
  gl/lib/openat-safer.c
  gl/lib/openat.c
  gl/lib/openat.h
  gl/lib/opendir-safer.c
  gl/lib/opendirat.c
  gl/lib/opendirat.h
  gl/lib/parse-datetime.y
  gl/lib/pipe-safer.c
  gl/lib/progname.c
  gl/lib/progname.h
  gl/lib/quote.h
  gl/lib/quotearg.c
  gl/lib/readlinkat.c
  gl/lib/selinux-at.c
  gl/lib/selinux-at.h
  gl/lib/stat-macros.h
  gl/lib/stat-size.h
  gl/lib/statat.c
  gl/lib/stdio--.h
  gl/lib/stdio-safer.h
  gl/lib/unistd--.h
  gl/lib/unistd-safer.h
  gl/lib/unlinkat.c
  gl/lib/unlocked-io.h
  gl/lib/xalloc.h
  gl/lib/xgetcwd.h
  gl/lib/xmalloc.c
  gl/lib/xstrtoul.c
  gl/lib/xstrtoumax.c
  gl/lib/yesno.c
  gl/lib/yesno.h
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: gl/lib/_Noreturn.h
  gl/lib/arg-nonnull.h
  gl/lib/c++defs.h
  gl/lib/warn-on-use.h
Copyright: 2009-2022, Free Software Foundation, Inc.
License: LGPL-2+

Files: gl/lib/alloca.c
Copyright: D A Gwyn
License: public-domain
 This file is in the public domain.

Files: gl/lib/alloca.in.h
  gl/lib/areadlink.h
  gl/lib/basename-lgpl.h
  gl/lib/careadlinkat.c
  gl/lib/dirname.h
  gl/lib/error.h
  gl/lib/hash.h
  gl/lib/stripslash.c
  gl/lib/uniwidth.in.h
Copyright: 1990, 1995-1999, 2001-2022, Free Software Foundation
License: LGPL-2.1+

Files: gl/lib/argmatch.c
  gl/lib/argmatch.h
  gl/lib/basename.c
  gl/lib/closeout.h
  gl/lib/dirname.c
  gl/lib/fileblocks.c
  gl/lib/modechange.c
  gl/lib/modechange.h
  gl/lib/mountlist.h
  gl/lib/parse-datetime.h
  gl/lib/rpmatch.c
  gl/lib/save-cwd.c
  gl/lib/savedir.c
  gl/lib/savedir.h
  gl/lib/xalloc-die.c
  gl/lib/xgetcwd.c
  gl/lib/xstrtod.c
  gl/lib/xstrtod.h
  gl/lib/xstrtol-error.c
  gl/lib/xstrtol-error.h
  gl/lib/xstrtol.c
  gl/lib/xstrtol.h
Copyright: 1989-1992, 1995-2022, Free Software
License: GPL-3+

Files: gl/lib/basename-lgpl.c
  gl/lib/c-strcase.h
  gl/lib/dirname-lgpl.c
  gl/lib/filenamecat.h
  gl/lib/getdelim.c
  gl/lib/gettext.h
  gl/lib/group-member.c
  gl/lib/hard-locale.c
  gl/lib/minmax.h
  gl/lib/pathmax.h
  gl/lib/printf-args.c
  gl/lib/printf-args.h
  gl/lib/printf-parse.h
  gl/lib/realloc.c
  gl/lib/rmdir.c
  gl/lib/safe-read.c
  gl/lib/stpcpy.c
  gl/lib/strdup.c
  gl/lib/strndup.c
  gl/lib/strstr.c
Copyright: 1988, 1990-2022, Free Software
License: LGPL-2.1+

Files: gl/lib/c-strstr.c
  gl/lib/c-strstr.h
  gl/lib/fchdir.c
  gl/lib/gettime.c
  gl/lib/i-ring.c
  gl/lib/i-ring.h
  gl/lib/isfinite.c
  gl/lib/isinf.c
  gl/lib/mbscasestr.c
  gl/lib/mbslen.c
  gl/lib/mbsstr.c
  gl/lib/mbuiter.c
  gl/lib/mbuiter.h
  gl/lib/modf.c
  gl/lib/nstrftime.c
  gl/lib/rewinddir.c
  gl/lib/strftime.h
  gl/lib/strtoul.c
  gl/lib/strtoull.c
  gl/lib/strtoumax.c
  gl/lib/time-internal.h
  gl/lib/time_rz.c
  gl/lib/timespec.c
  gl/lib/trunc.c
  gl/lib/tzset.c
  gl/lib/version-etc-fsf.c
  gl/lib/version-etc.c
  gl/lib/version-etc.h
Copyright: 1991-2022, Free Software Foundation, Inc.
License: LGPL-3+

Files: gl/lib/cdefs.h
Copyright: The GNU Toolchain Authors.
 1992-2022, Free Software Foundation, Inc.
License: LGPL-2.1+

Files: gl/lib/closeout.c
  gl/lib/filemode.h
  gl/lib/fpending.c
  gl/lib/fpending.h
  gl/lib/quotearg.h
  gl/lib/save-cwd.h
Copyright: 1995, 1997-2022, Free Software Foundation
License: GPL-3+

Files: gl/lib/euidaccess.c
  gl/lib/fnmatch.in.h
Copyright: 1990-1993, 1995-2022, Free
License: LGPL-2.1+

Files: gl/lib/filemode.c
  gl/lib/idcache.c
Copyright: 1985, 1988-1990, 1993, 1997-2000, 2003-2007, 2009-2022, Free
License: GPL-3+

Files: gl/lib/fts.c
  gl/lib/fts_.h
Copyright: 2004-2022, Free Software Foundation, Inc.
License: BSD-3-clause and/or GPL-3+

Files: gl/lib/memrchr.c
  gl/lib/strtol.c
  gl/lib/timespec.h
Copyright: 1991-2000, 2002-2022, Free Software
License: LGPL-3+

Files: gl/lib/parse-datetime-gen.h
  gl/lib/parse-datetime.c
Copyright: 1984, 1989, 1990, 2000-2015, 2018-2021, Free Software Foundation
License: GPL-3+ with Bison-2.2 exception
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 .
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 .
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
 .
 As a special exception, you may create a larger work that contains
 part or all of the Bison parser skeleton and distribute that work
 under terms of your choice, so long as that work isn't itself a
 parser generator using the skeleton or a modified version thereof
 as a parser skeleton.  Alternatively, if you modify or redistribute
 the parser skeleton itself, you may (at your option) remove this
 special exception, which will cause the skeleton and the resulting
 Bison output files to be licensed under the GNU General Public
 License without this special exception.
 .
 This special exception was added by the Free Software Foundation in
 version 2.2 of Bison.

Files: gl/lib/str-kmp.h
Copyright: 2000-2022, Free Software Foundation, Inc.
License: LGPL-3

Files: gl/lib/strtoimax.c
Copyright: 1995-1997, 1999, 2001-2004, 2006, 2009-2022, Free Software Foundation
License: LGPL-3+

Files: gl/lib/uniwidth/width0.h
  gl/lib/uniwidth/width2.h
Copyright: 2000-2022, Free Software Foundation, Inc.
License: LGPL-3

Files: gl/m4/*
Copyright: 1992-2022, Free Software Foundation, Inc.
License: FSFULLR

Files: gl/m4/alloca.m4
  gl/m4/getline.m4
  gl/m4/getpagesize.m4
  gl/m4/idcache.m4
  gl/m4/intmax_t.m4
  gl/m4/malloca.m4
  gl/m4/mbrtowc.m4
  gl/m4/mempcpy.m4
  gl/m4/memrchr.m4
  gl/m4/mktime.m4
  gl/m4/modechange.m4
  gl/m4/pathmax.m4
  gl/m4/quote.m4
  gl/m4/safe-read.m4
  gl/m4/savedir.m4
  gl/m4/strnlen.m4
  gl/m4/xstrtod.m4
  gl/m4/yesno.m4
Copyright: 1997-2022, Free Software Foundation
License: FSFULLR

Files: gl/m4/codeset.m4
  gl/m4/d-ino.m4
  gl/m4/fstypename.m4
  gl/m4/stat-time.m4
Copyright: 1997-2022, Free Software
License: FSFULLR

Files: gl/m4/gettext.m4
  gl/m4/intl-thread-locale.m4
  gl/m4/intlmacosx.m4
  gl/m4/po.m4
  gl/m4/progtest.m4
Copyright: 1995-2022, Free Software Foundation, Inc.
License: FSFULLR

Files: gl/m4/gnulib-cache.m4
  gl/m4/gnulib-comp.m4
  gl/m4/std-gnu11.m4
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: gl/m4/lcmessage.m4
Copyright: 1995-2002, 2004, 2005, 2008-2014, 2016, 2019-2022, Free
License: FSFULLR

Files: gl/m4/nls.m4
Copyright: 1995-2003, 2005, 2006, 2008-2014, Free Software Foundation
License: FSFULLR

Files: gnulib-tests/*
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: gnulib-tests/_Noreturn.h
  gnulib-tests/arg-nonnull.h
  gnulib-tests/c++defs.h
  gnulib-tests/warn-on-use.h
Copyright: 2009-2022, Free Software Foundation, Inc.
License: LGPL-2+

Files: gnulib-tests/accept.c
  gnulib-tests/anytostr.c
  gnulib-tests/arpa_inet.in.h
  gnulib-tests/binary-io.c
  gnulib-tests/binary-io.h
  gnulib-tests/bind.c
  gnulib-tests/connect.c
  gnulib-tests/fdopen.c
  gnulib-tests/fpucw.h
  gnulib-tests/getpagesize.c
  gnulib-tests/getrandom.c
  gnulib-tests/ignore-value.h
  gnulib-tests/imaxtostr.c
  gnulib-tests/inttostr.c
  gnulib-tests/inttostr.h
  gnulib-tests/ioctl.c
  gnulib-tests/listen.c
  gnulib-tests/localename-table.c
  gnulib-tests/localename-table.h
  gnulib-tests/localename.c
  gnulib-tests/localename.h
  gnulib-tests/mkdir.c
  gnulib-tests/nanosleep.c
  gnulib-tests/netinet_in.in.h
  gnulib-tests/offtostr.c
  gnulib-tests/pthread-thread.c
  gnulib-tests/pthread.in.h
  gnulib-tests/pthread_sigmask.c
  gnulib-tests/qemu.h
  gnulib-tests/raise.c
  gnulib-tests/sched.in.h
  gnulib-tests/sched_yield.c
  gnulib-tests/secure_getenv.c
  gnulib-tests/select.c
  gnulib-tests/setsockopt.c
  gnulib-tests/sig-handler.c
  gnulib-tests/sig-handler.h
  gnulib-tests/sigaction.c
  gnulib-tests/signal.in.h
  gnulib-tests/sigprocmask.c
  gnulib-tests/sleep.c
  gnulib-tests/socket.c
  gnulib-tests/sys_ioctl.in.h
  gnulib-tests/sys_random.in.h
  gnulib-tests/sys_select.in.h
  gnulib-tests/tempname.c
  gnulib-tests/tempname.h
  gnulib-tests/thread-optim.h
  gnulib-tests/uinttostr.c
  gnulib-tests/umaxtostr.c
  gnulib-tests/usleep.c
  gnulib-tests/w32sock.h
  gnulib-tests/wctomb-impl.h
  gnulib-tests/wctomb.c
  gnulib-tests/windows-thread.c
  gnulib-tests/windows-thread.h
  gnulib-tests/windows-tls.c
  gnulib-tests/windows-tls.h
Copyright: 1985, 1987-2022, Free Software Foundation, Inc.
License: LGPL-2.1+

Files: gnulib-tests/atoll.c
  gnulib-tests/setlocale.c
  gnulib-tests/symlink.c
  gnulib-tests/test-binary-io.sh
  gnulib-tests/test-btowc1.sh
  gnulib-tests/test-btowc2.sh
  gnulib-tests/test-c-strcase.sh
  gnulib-tests/test-closein.sh
  gnulib-tests/test-fflush2.sh
  gnulib-tests/test-fpending.sh
  gnulib-tests/test-freadahead.sh
  gnulib-tests/test-fseek.sh
  gnulib-tests/test-fseek2.sh
  gnulib-tests/test-fseeko.sh
  gnulib-tests/test-fseeko2.sh
  gnulib-tests/test-fseeko3.sh
  gnulib-tests/test-fseeko4.sh
  gnulib-tests/test-ftell.sh
  gnulib-tests/test-ftell2.sh
  gnulib-tests/test-ftello.sh
  gnulib-tests/test-ftello2.sh
  gnulib-tests/test-ftello4.sh
  gnulib-tests/test-ftruncate.sh
  gnulib-tests/test-getcwd.sh
  gnulib-tests/test-iswdigit.sh
  gnulib-tests/test-iswxdigit.sh
  gnulib-tests/test-lseek.sh
  gnulib-tests/test-mbrtowc-w32-1.sh
  gnulib-tests/test-mbrtowc-w32-2.sh
  gnulib-tests/test-mbrtowc-w32-3.sh
  gnulib-tests/test-mbrtowc-w32-4.sh
  gnulib-tests/test-mbrtowc-w32-5.sh
  gnulib-tests/test-mbrtowc-w32-6.sh
  gnulib-tests/test-mbrtowc-w32-7.sh
  gnulib-tests/test-mbrtowc1.sh
  gnulib-tests/test-mbrtowc2.sh
  gnulib-tests/test-mbrtowc3.sh
  gnulib-tests/test-mbrtowc4.sh
  gnulib-tests/test-mbrtowc5.sh
  gnulib-tests/test-mbscasestr2.sh
  gnulib-tests/test-mbscasestr3.sh
  gnulib-tests/test-mbscasestr4.sh
  gnulib-tests/test-mbsinit.sh
  gnulib-tests/test-mbsrtowcs1.sh
  gnulib-tests/test-mbsrtowcs2.sh
  gnulib-tests/test-mbsrtowcs3.sh
  gnulib-tests/test-mbsrtowcs4.sh
  gnulib-tests/test-mbsstr2.sh
  gnulib-tests/test-mbsstr3.sh
  gnulib-tests/test-nl_langinfo.sh
  gnulib-tests/test-perror.sh
  gnulib-tests/test-select-in.sh
  gnulib-tests/test-select-out.sh
  gnulib-tests/test-setlocale1.sh
  gnulib-tests/test-setlocale2.sh
  gnulib-tests/test-verify.sh
  gnulib-tests/test-wcrtomb-w32-1.sh
  gnulib-tests/test-wcrtomb-w32-2.sh
  gnulib-tests/test-wcrtomb-w32-3.sh
  gnulib-tests/test-wcrtomb-w32-4.sh
  gnulib-tests/test-wcrtomb-w32-5.sh
  gnulib-tests/test-wcrtomb-w32-6.sh
  gnulib-tests/test-wcrtomb-w32-7.sh
  gnulib-tests/test-wcrtomb.sh
  gnulib-tests/test-xstrtol.sh
  gnulib-tests/test-xstrtoumax.sh
  gnulib-tests/test-yesno.sh
  gnulib-tests/tmpdir.h
  gnulib-tests/tmpfile.c
  gnulib-tests/wctob.c
Copyright: 1991-2022, Free Software Foundation, Inc.
License: LGPL-3+

Files: gnulib-tests/glthread/*
Copyright: 1985, 1987-2022, Free Software Foundation, Inc.
License: LGPL-2.1+

Files: gnulib-tests/inet_pton.c
Copyright: 2006, 2008-2022, Free Software Foundation, Inc.
License: ISC and/or LGPL-2.1+

Files: gnulib-tests/putenv.c
  gnulib-tests/strtol.c
Copyright: 1991-2000, 2002-2022, Free Software
License: LGPL-3+

Files: gnulib-tests/strtoll.c
  gnulib-tests/tmpdir.c
Copyright: 1995-1997, 1999, 2001-2004, 2006, 2009-2022, Free Software Foundation
License: LGPL-3+

Files: gnulib-tests/test-dynarray.c
Copyright: 2004-2022, Free Software Foundation, Inc.
License: GPL-2+

Files: gnulib-tests/uniwidth/test-uc_width2.sh
Copyright: 1991-2022, Free Software Foundation, Inc.
License: LGPL-3+

Files: lib/*
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: locate/*
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: locate/locate.1
  locate/locatedb.5
  locate/updatedb.1
Copyright: Copyright (co 1994-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: m4/*
Copyright: 1995-2022, Free Software Foundation, Inc.
License: FSFULLR

Files: m4/nullsort.m4
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: tests/*
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: xargs/*
Copyright: 1985-2022, Free Software Foundation, Inc.
License: GPL-3+

Files: xargs/xargs.1
Copyright: Copyright (co 1990-2022, Free Software Foundation, Inc.
License: GPL-3+

License: BSD-3-clause
 The BSD License
 .
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:
 .
   * Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
 .
   * Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution. 
 .
   * Neither the name of the copyright holder nor the names of its
     contributors may be used to endorse or promote products derived from
     this software without specific prior written permission. 
 .
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

License: FSFULLR
 This file is free software; the Free Software Foundation
 gives unlimited permission to copy and/or distribute it,
 with or without modifications, as long as this notice is preserved.

License: GFDL-NIV-1.3+
 Permission is granted to copy, distribute and/or modify this
 document under the terms of the GNU Free Documentation License,
 Version 1.3 or any later version published by the Free Software
 Foundation; with no Invariant Sections, no Front-Cover Texts, and
 no Back-Cover Texts.  A copy of the license is included in the
 section entitled "GNU Free Documentation License".
 .
 On Debian systems, the complete text of version 1.3 of the GNU Free
 Documentation License can be found in '/usr/share/common-licenses/GFDL-1.3'.

License: GPL-2+
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; version 2 dated June, 1991, or (at
 your option) any later version.
 On Debian systems, the complete text of version 2 of the GNU General
 Public License can be found in '/usr/share/common-licenses/GPL-2'.

License: GPL-3+
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; version 3 dated June, 2007, or (at
 your option) any later version.
 On Debian systems, the complete text of version 3 of the GNU General
 Public License can be found in '/usr/share/common-licenses/GPL-3'.

License: ISC
 The ISC License
 .
 Copyright (c) 2023 by the copyright holder
 .
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
 copyright notice and this permission notice appear in all copies.
 .
 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

License: LGPL-2+
 This program is free software; you can redistribute it and/or modify it
 under the terms of the GNU Library General Public License as published by the
 Free Software Foundation; version 2 of the License, or (at
 your option) any later version.
 On Debian systems, the complete text of version 2 of the GNU Library
 General Public License can be found in '/usr/share/common-licenses/LGPL-2'.

License: LGPL-2.1+
 This program is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by the
 Free Software Foundation; version 2.1 of the License, or (at
 your option) any later version.
 On Debian systems, the complete text of version 2.1 of the GNU Lesser
 General Public License can be found in '/usr/share/common-licenses/LGPL-2.1'.

License: LGPL-3
 This program is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by the
 Free Software Foundation; version 3 of the License.
 On Debian systems, the complete text of version 3 of the GNU Lesser
 General Public License can be found in '/usr/share/common-licenses/LGPL-3'.

License: LGPL-3+
 This program is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by the
 Free Software Foundation; version 3 of the License, or (at
 your option) any later version.
 On Debian systems, the complete text of version 3 of the GNU Lesser
 General Public License can be found in '/usr/share/common-licenses/LGPL-3'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Document: findutils
Title: findutils
Abstract: utilities for finding files--find, xargs, and locate
 These utilities find files meeting specified criteria and perform
 various actions on the files which are found.
Section: File Management

Format: info
Index: /usr/share/info/find.info.gz
Files: /usr/share/info/find.info*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [{֒&|3M)!iKsw[DӶf~2 	Rئ 6 J'}:|މHbaj񭪫Iϋr6Ɋ,lқ]ΟyU~5:M=q\7YΖi~K<bW1|6YțY2<YM?ڴΛj]O֦M*ΗtjEӤi̪&/tZ*g
?ay<v0i{w)TM],t =zãEe5o:O_Tr40=+h뛢{h*:+i%):Lg4[,AU7լoh.E##i$[g<bbM>A~ֵܤˌMX'ˢa;AwE{-6ZUzOfT4|zoC_Mߎ;bZyϊr\hbE_,풾6썓goF'Wgظ^dew6:~s5ߝ_-"}Zt?8vH)9=:oɋb?ݾ}y5ϯ7SWR(,}]4YQ_oWIҟ8߭_^W^M/M(ӳY	*oyj||UUK
olR,vCYD$BoD/u2:<º,<kt&GYI}OoIΣN.].o"5Q8]2QʧżaaWNdj[zϚH[VU/+Q)k̊ rzo.sbk
ݩ冾[2W6hliB߯!MgJS+K7wmRuƗg1Nns~IY*8js@n[	>7N*[0-|cnhjvRV?͚w)
)ܼO4Y/FΓ(c3,i -M|@o
.l4L	,.A{t:To7₸~LYZo&D<7r7[>´e5	Bm~l@=,G,ä:I*1ƴYC<hfq+&2K]Ҷ6LyWf ]l d`L&^YD{vDڶs&7=D`,f4źay~&ELMCdSl%R$]fY*_!{Jsޏ>˥~3>E8<P,V@d茗y
uCGIF%s` W:-U4L'tyɬR3a@uU{!= MTǶ$"I0"^KwXCTRКOdRίݬRgr+f6kmW>Čx2PGe9
imqe|A 	UNh9-D.۪mHmCO4IICYVȀ?؎s>k752,]
)4l67ŵ4ڤu9UŪ.I^^udA
	;%fp1G^TMImhtvJkӁj)<zC(=%i%tHSMhEW  K)Bl=) zU`#)etƓr$gHI3NQ5iEMuG-<12mI>8!̿WVq~F'%4}dv<8:&MȟnW^"=QI>X{}qyk<+)
0ê֋H6:kF"= ׅ;Mpi]0+[zLL#A`ۘVWa|M6Y
Tcns3K:J:S4Cxu;-iVg,!ΪXͪU]%bnKq:fGMGkSUwg.ɘҳ<y,A<5T#٘Jb4MiV]~L?XGŌot
|mM:},4 P8}+63Ku6=,Oɉjbȴy::q3lymo֊S ;*pǺl/fy)7Lva\YA!BR?V>YVw
vR@HdUU9SIk5ϴ}GP.byI!}uF?.T.ytƂuFG#Ã2G`I _ |=[ʬ(R,ľTY{!Iޘg*
~D㭲9>F3O0ሇ5̥?{yXr%Bwj좪f !
繘;L_ƣd	1Y1khۇbu]XGW.#/ԩVHy+H^ʙFP͜I=Ā46/OfX$wAȈZZ>9N%klXPӻ&_`w`,+
k®'N46UԵW?ɨWXE:zI.7N(_|R|-1ϓS=iE#eVdjp72j4+9B"v1ҽ"RT?ٻ$Ea	Ք퀺zG
WBQd͒>{v7sd)i:ǪٰE櫟+∴L)ڧ2me
6|%6>PXͬeqMiUE͌*aNL3I࠳s7C^HdʙǰiX6d㣕@`HgТDGp%qrki
F]o6xk>yV,@!Ӈ'Aτ{5-6n[q7#j6f|v}JӪh.ebw9L`tE
lٻčH_IbQvkۜߵ3哜V%6tzؤ֤ۢaÑZkKa2dĠhU`cvJT'lq5&4wKfnUɷЪ -ha~<ɦ׺FvTb׬c =-nm:#brr5v3ξ'f 8b:)1qf.$V4I)LpTjWf"2ö E![Xz!-O.<cDyI(ydid:Fbx@IY/AlҜuwqbu4Ѕ&SlPnMwLE$THbŲܚ	i|I_q̯eQB4#'ogK>	SؕkĬ1458/ XaY#^o	O7a:;:%ҕxٛEbnmBJI*?^C2KPx	ٴb!PWtiVin	ohKM2p]j&z9ZL+5]\PzP՟u)n\0ԡD׻ .H[6 *v:ωeg%lүT[vg6-OMdZԴELSq'd,'|N/¿!tvQd,p
|=oax*߄z
M/E'"Aޗg
QM"}JP#q}ߊTrǆO?I관Ek"יsL1/V2Ql0Me^P797ivqd1=P"!I[\^y xP3W\$ʑ1O+9fw:+;1Yr	k &Y?ߘXyfnr4j'/7)eH_G\1`,^&NzЈDߋm,:m(X7찇Gb-"::yߴ珎[^ʜ1ḇ#rV'cg;ubY,Z0Te 54<9y'KDhb=UzX)Bq>wXD̉FIĨd%VDS{ڏCI,/LUϻܟJ>]+"Z3xF )緥7.rؚ:e8Ih+J1) $n6Rd{6{^b[2hOČY?;р8ZTA1ʺYz!A˔O,<A)Hq9d9$1`uw"d9C3/ϙCis:1 Ya~
H&C|,rrdIC,[}
QJF'QȊ)Bfڻp@w_v3ܠ8&%4(Tp^W]yD$+#}FLɦ
^dVZ`lMa4Hax^W3q͌&}ӓ+7Ov.7,o	3W9v"EcW{EyXzɳ;*r}pdң 5]Xv&Y'{Kf-3 EAH^b^lFxa~@8ľ1"QJ.vUYY!OmOhI`T:x5"x+C]I΢;J/W@)Ǘ'ggۗoe.	x$gk AZCi_cS$k.abӿ@|%{Z?,be0tLƘ_oFsV"ᇞ)W,1'h,PI<0yvǲ~Qה"ޣ;{1YdUɍeZ=8dcH_MsqbшitFq+}3%A#{ż7!_D9)zD(v{=F)YS79X5E_FA㍶+`BN@DHv<*p<-g!VϜ-&>n}r3T}hxxt}[C89:Y3p-5`"kckߩсWN $tNΒ(,4V
ft-؊UְuBDfa*n Mif;GZ`l89βi>0hT9N1vW2ٴZ!XZg)D41<*	d<]-i?EeܳYWQ0<tzl_>
7jTЃncEMWf`8erel+9U=uEOAZ[6XHrkX3e1UpDH/Pb$Nq!TpB6Y0u	Lܑ&OæMP;WLk1|y,L8)c^-Eduhz v9Meu] d0K:ifcV_^0F_o()$$`0!11L~þ!"3+fe"G"V!N%2 Ai"mF`;f/ɳedC5OJ&b=,__,xť{ Jz22//2H6;nC/58QgƗm]b&ZzZ p-	oúj`>	x	B.KGF1,R]$r&Kv _2
>Ф}K3E\ɝ?l[E99-a/ubDR3D 
$˳%%@h1qFyWD0P}cZfղXNz  <; `BG#[mnڒیҩ5&Bj3o\]Yj38r?1V XDܘi'SJ
gͳ^aMRqrElJܹoHS@[V(*`q
i^&ꉎ0ΊRkz%r
G-D0LB@
s$ݧN~4Po檪cSυl`&NTN
|i03b9&4ˇկf˖m6ꚝhP>}].5Y5@鱌)"3a\UU
 Z|\4k$Ay-
/S]ھbVuїIEG	C8-:
L;j`&SY,OUMg"vÊ+T{~0fw-)nh#LS!YF@9#M<LusM+$Ȱw{zkeɌ[ "^k0lI4h Ė?	?>Wޞ|e'26р=I2SAZ#}aa|:}@V};qLdME2rNxTSy
tl-`xi4wf_>ya݇+2DFy:I
Dfkb#sVT0#M.ȣ<ҔTvsLjTT^ZZqts,:W|zŘ{!bQ⣀+?jթ0i<J#8'ɳMԄC/ڄ {
m%HFA`,
XeyWlU(|xLXY-Bh Riٽ=KU]q71?C"Szǰ mf):d Jz8)X$GO9n>HEh;q9}"&,}7;G"C̓F
L|6WljqcXDBfe$JMNs	As
@V\񽉑ʁ8-Mu=\KgV4 ;NlT$};*3c{Kl 
c`&ˀO2l N3/оcCznJ-D'a(Y3,Jq VݲkלtҀb`c	ӲI4 &,zeҔXi{>ӉsBoُZ:&ycP}@pzWPϤ9^ԧ`[n\*
uVb
"!`eZ"5?O{)9θ-3ڣ!KlƐ^D<(֧(sEMqs^Ǉ@}^b:h4ٜnUx`z%y7l
ʲxǲ&eQL14gBZ[n+ip'Qn7
x,kKuuu`9%S59jN΀aЀS[&,;0]"j|AC4ٍg4?0)EYz:3@fݑb8a`#Y
qGH+LM6gW\%ս
E&JzBz\yu	XЬfJ*[xv/	.h2+#5(d%y1pXuYr<\Ɯ+bT>E0p(̕*K$Na8kn+<ȍC[ 
*Q
:z'@YZv[v0A`A`RdL* V\K˖-CA28`/_T{۩ZѰ^u<'K8:3-qS
.W=Jw
ddΈ$=CشT?W,3,RV	SF@zǇ5&,h-!Ff p4sP*"d߳H$[rA
' aHH; Ce6R7n5k0RC`X!YI!-8$lO=68"~j0DMAt"WfxQkk'?t釾fmI.g|fRxKW=AȖ
ŝi=-eT{L0'1_"	fz4M>0c]dRX)DݙhT:f2#ݙb09{4 qB˨3\XSg0	k~&5~n*jZ`@qv^ ab)YM0dF
0ە2t^[*y$rUK:|kL
f.#݅N) ucX'T7hGT5V n4~Z9؂
2$z/,7091$ݓ8K&ˎ^$BѣPڮM8S]HUpZvZXS;{0v?b \c/6R+G8Q`E7k5gau.e#)BoOqn먮[ZgEGHMYP_A}ȭ
N6-]eUڍcX~.9NyHWV#y GxM:;C_鯛M9$(v:8wo9ԡ y*Pc|Uf4M< Uʋ~9TrDz@u.utW7q	q`o4!u3[߀P<6iy(VP,pa
)l1([JܒhR/p0Yo4ָX3(>_~,4ú2.* ៌dN1չ?J1 IhEaKS\2n;LT2ʡ"n4GCLDLr_3?yqHjK#-La0Mn:I*?\[r0Oj1`TFt\
~#ESnJ|Z,葖eYeSb,9EQŋ_&:z0<ԭ
R_  ⼷|)]wF΢aɿ.ң$N>\ gl]	xPib7hpVQqtR@,9yV&"_fd3"gD:;T7vG>Dz5Bm^fE*Bj%m%&!i<3]iaU51"LGUYF=K
u
Xel<Q9+w<(_a~--k*bZ@_v^19=ɝIѪFϗ>'W#(P$K+i4̮.Ea6̎|
YDuir7o{+iM:OYa?'Fo^k<)@*}vw;h+z,wZN6娸/Hb
d?P=d<в
j!vt6~KP3~|%?]:}@:/{n;y\dvuh@G<7&+V!-\+Z0$V㉞E\ 2~Ft@B9Lh\z.!t-B)GZ6\{ =/Dv`Sx1ĵ 1R#u$MOol/ZIcZ9# N}Yx?~u^`o[
2\F
@ȷVǆFQܛXPV\,2.5T$e@4w0c'B\	58grcM[ipKMx F;rev9yacQQKiZe
S._~&MN+Jl&u~KO^[|5[fЀ%DayEF##>^oS$;aByt[4Q!Y^ ,(#
QvqOةC~U pJUA~Du{N
D{Bʺ5[w}t@Oe$sfD` DAK;FDTȐ
Zgk_rgɿb&]D_E3Q˺&	#"5xxش440/	(S:GkV1tQ9JĨr&%\2@(ql	!M!"'nҀ
681D^Z01&P?fsǄ8*4]_{$J&4Uk"ݪzᠵ/3H!,($IC2uxܨПƀH̩.٪r$x+Hc@}'6SӁ(`j|}Sбm%ֻi;f?`~\}[Z8?m~M4/1"j	růf9;HkA6*Wu\CGeD%*(oμuȂDaQ+I٤uYa8EG5@W1gw	b#i}y`|<7E¥%TYEz4Q'nU@ˡC%*:q*\U{Pb9h=,Ji,Bn0LUgUˬ=iS)AQRemwؘu6B:GaCȁH]b29]Vq/bV]oų,?({@Q"2IH&y}kQLqhPCyI/X)WgJh;<B>RZHl*<@ G;hП@Ɓ"uO-F$i]ywvY-	-jѮ8ʉx;<3y<~4~ϮɘK6D)od߲s;ck*okdUp|
-R޴A`
=FOy+̭>z.ޢҿawdz	P~2~xf10բ]"9¶@][7ݙ}%mve,5Zm͇Z(PK3\xm*4/cwdKrq$MM?T+:_9͙)gf%@zi%tl9/O:GjEjZ^GaR}|(À3dŴy٠u&q܀ՙפW3@C
]Oo_7Mm7H(oaDo]>Z
k!h˾&*} %5)8E'uX`=F`;GJG74R`yi`ҎIn*rZkVk7Z=0 NiEVE
ID
}MWIU5{^;q"RW9'	V҂y|,Svz]wC8Дs!g{2al롶2*MxjLu^w8O
hwFɉC:勎FSȡ^h:g	B1vz)ʁ[U,ժ乃59./7 ʅxiTӑ:N#ߤ/,$@Zb>3yo{ƴto5.DëWC3ujAx@!ᨰ`	\f-$/]37ٌUdV5U43V c"x+Le
k"['d4®VD	')Yhϱݕd)|EyOE%;a~lJ$Bg]+fID3m
#?mm!&$g1ŇOIU?/IIEM	*>IG[LPn5v3Ìts:
..f$!\?Ф$AOo,(	jOγ>Fd~hzt
iRү(Itq?s!F+bXA!OmYI 6]S`{sc'E8ژ秗'o^_]5W= F,g#/i$?PD]2JS#I@
^iXÇG_&{0uF֣(V@|
7rWSp6<qCZf9H%&W~?/u7H˯N1IґIJ! U-mb LD/<D!Ҭ)Sq@	5`_u 8+콼89:}x̶@y@[mkUg="ŽBY7q[~]cj |55<zz`n(^Ҥ$mw;3_)r;TjR	@\qZ)^h2ΐ+nWC`&$?ҷf#%=׈'kڳ,^8A[kNn{N>[Ӆ%4|׻ct~xe;c$ylՖCP)'OVzR_rd~k^jj5IkjmJAĀo>M= 7"7 P3$ȣY]#ۑ^Q#h+?qxuZ[.UͅsnEPt4uD^WA&*{&ws|9Txea %Qh_RwtR>뗧7zI'*d'Ӛ&nz%KdM=_tmz%ns&Y\R؛wJ޼1>:}Kr"(̦rW,9qĠkE5k'Gu`.CĲsI֚yHtL5O$4
`/y&}Vr2d+9K֧9]GfE/.4[IZ~Y"|F?ܜt
ZPwj[O쳜Tt#a3dSKǣ0ytm8wJW4n^!'ty)"Ь^ˑF]0cҿ{0op_ Xw)`~uңe.$(x}Q֖yeS|4]-M}̼M??|oK?_Ӈ_Gi<3f~\\X/Hw6a)&i7NnD;{:&:֥~_ H/K?߷?XߑiIGWأmO0Y{QvnTN}OhѦGЛ{NNtд=qt>?ej0kQu_\l`l_gm
3-]FWF>xie2}OCy?Lv$)tPR@P#f%Dn"6}oSR4~*7Y{_~&Ko7//Owz:Gc]g WJwyȫYTc
k\U:wp&
{s
8~1\INڠW.бc~bG~=zd衻6"^es}cp=	>zc0}І	ڟ5~
u: aDN֜yg#REa:>@DدN~-i9DV{Gfc~ĭ\$x9d*`RO=^?2Л<MLozZuߊk:oxe:Zej*.*?;:JW5.Bz'_?}|HkyY_~ߐч>=W;Io/_H
czճXIhO^?-r_V=>Ľ>{o#G_tǊ>+ص+8gw%o,3bNW_}%2sP_.ʴggW\_=Ճ_2g	gINáƾ45TJo}q|aP=_~w&ʡM˯QʟS{a|{Lu_޻fqG~dC،_Ȣf34[D,[UYY/t9oig,[60&J}}w}e;.'[k~wV]5'K?zp{ԑ*uM9֗jshD/0+FixwzG=Hu.0j>gׇ@e]?Ehv)1'=7  YNK9_n+_|ŋWaѱ{e-d|><lyA
2۸W6\kv,ߤ}ҿ/Y?KSxiTDTq@J+
BvOԩ3>wѝ9<9~}w,)1Ŀ5tgf)~Wjt$1=z5ڭ7.(M*gT_?ﶦ9~}]1>-!ezS˝?_~wv:]Cef`|0=\;\/ŗ_w><4sGv﬏u\k:=VgzKqu?,j3HpyF@fJ5S8||>;F]1YsdS|`gKV.oI'8jD5ɟn> F0V7H~~~w_uizvͫ{1*WxYXW[g5j6D{ cF"ٙx	HP&JEuPWIv\QR1L=20]ܹ_'
׎6
+u8^Y!HCnH06*Ig'mL䓄SI?ZM<Ǵ:{iTgM}Fn,dv	WM_J+G Q~5]<vR[ЀE#{]q%
/|//_J[_R(}0@ר}H;
R\  =%*ĶU@+V Z. >]VҵYLwީCmAVF
dG6F7}ߏ2znw>}/L_Hn)i8$^I.ֻZZA^ަoޞ~˳O:n7i7MLUyv\`-. ]60W,1FV Ӳuv=UBUD=iQ8[M3DPǳYEd>C.ңOOgEknZ݀{I g8" m!KmlǾ{m~4nENT>ഴѶbmPf%8/l7D٢{y lT4}<~B/e|˗9@&k%;W>Htt)u亮7=XUyB;j(6O 
#xGWi;dw-7[HoBJ t^nDID\`&J2"Dos3ķ_gH\ȷϷ$;Y5˝4qyjWl qf$?~
eD6oޔ!PP"kQc[ڕ
xA]{喳:~p`$oH<Uaoe47<u:*y؆;{},C(1g>>^ZATNj[օI q!VqJPd,3a%9 tLi4h8v%l{w1y$(- Ac@OgPGctLsb;Hv1SH-)!Il}sMbK;c(9{oի$QY&yIAF3t߼D\$G58@$lE!I^)t(ƪ3	KP4Ck.~'a^ gHa[Ye6h;ѽ}$,M^IY5Wk>DsapQڳ}z>~V0}DGNp{=~ո2ob{N9s  C@=AM	
}c=tVVGdв2o^i#H߯ߜiYkbCkZeR!q=f
BeULH"]mrniKm{f7鬺ye5	=`Cȧw6Σ-+ڡkAyyDOԍ0J ZkeUƟ&Y],-vhU<iLEH+tdJsٜ
U<koP9T OQXō_F⿬tzBPmu7o":,}WHV!WV޳6#Qkz!f]phM/ospȂ6T}]DDyDk%EB͒*8oO}QK%񀁖Mr&B=@`u>w:ŮZ>|		jk. soڒsOv3 z|*+sJ4]1/pt?Y=NΊ6Z)0EqP[3ܛ8sH*VҾ8yVhCjdWBg'?<-=>>?}qv~>]7zqRtG#OoDiV'KZ?ɔ97˥5)im,/T)VH#G]Unj-9qiwm]ЪfZmZI'h2z=qf~<gr}o(.z-WU#>ipָf3.%GZY\Nd9hs>J	B$St#&nD-|hR@%E =kmɞ-S0`7F
\oe/z<;
)L$Te#5.JV
/IXg{gpÒ:plI(zGQَ=s:dc5g-~k6u҇h"+CU+>A3ḱ;RָEvQ3|:sAn M_]s|ѝ23(\.<v[ahoL{]?9>7<s^exp)xJ)wnzL Y#kH㩚5?IvM\7ZMu)WjtQy7k>Ri\hբ(
Z8V%y5ChTeU]`;5xiˣ0ֹ֫
yXSd	hF^IaӁ#S=
mg\`1S~yqhHjx9$)^m*:!T 2~0Ti Kcj!?H'JS=콷N 	s~k'#zHX4=dJH#9MIhW
NJAf碂Y)4G5ZMTYݣ+q*Ĳ~v꧊PYK+=$7 65hUϗ;6B5{|VgJ?lD;\֨?wڊr%jFܪȚL8bQof=`"뾗D9< !A&^X$9fXWP!I"Di75k87 6RK)H&`xCZzǊf}P6׎X1R.ÅU@ IݱsٽB('F${gT5N5"xđ>dg'gg[k[t-evL|7W2/QeGˬttKIť_?ѵx{g3{aLQ89E}'ژv0˳v/_Qˮl:34TkJ0:b;Ә)Q-C]PWG1j߷+QM8*YKpqv7k=Zck΂؊r1BvL?۵Cvo^*4o@boTQk~HG;_G&>0feM̳KSÄye }A<&!{鴼1fy_
"=\d8X*Ͷwx&RwZb޳U
9bhcZl(A*Af؛L44+~و)md?}1R˻f:㽑JL⃰Nb!="d󔋗55k'XG{^ai['G@Y)ku:lFnzg+,b޹/DcIblg7xkV[d=c?~sv3if>oVH7DmB樜1RrN_lZy+)X`g:=.m	 4&q+ç B^ڊH7u폎+Rdw04:ƈqPAJ /M
_eD-iB˧0l|-R:i+u#Mߊ?!
cpm:fhދ2-/kn۫};~Ÿ]!QػgKF-JHSZR8J_[D7mKپVvhܣI<
na-}pZCHZ*az/ף݉<_oϯή~x2}Pf˜Y<z&5eUkCwTػtv|Lܚ+6-d7SV䃿WDKC(ێs		\&Z8d)Q18m{ GԆi@Hr)׳G' &)u,vY㈲wqu*%3NASEHo5&Gjo_F}ٺC3Z-H0vwhR6jrJ3dSy\@
V$ܼNQ͕VbU{}ih0mn Rzp)V+)rQuoTJ/x}1y[S齗8;5UػkzPlg}J:
*Ry9(mQ+)#qh)ǿ3_$poyr<YE~xVoQ`oZ}"	H.0ްϺ
ղ(&l(}bL2[=DqA1؎Ir6^MWEJ|_D#e"=es{]C' ޕnG)Zp.2rۈ<S7ڱgn֦{CY7XӶ׀s[fvG|nT+3!Fmn4n1mqOn$ً*!<KqdgDaG4tLmXno=l_mq45mBѫClEdjG6Єnt끟Wȍ{accgWc2k"$Xw pnJj8A3Rkpj\Cx{Q(
Q%z{o.cTu
X{_ON\M	0Fo^p)Z+!f~(Rx;B M<3ϙ|CYI*F࿎]o C zc
Ħ<4@cww8)bd{j}xs$D[ЅAO[SIp,dЇsfRrý3ckiKGr2rY3b_f!]chE!ZBL
Dm:$}}ӭԖ?Fd蕞!VmcDDHWMؤ:`7Gct_&	9 Wl65nT=rc"f:!INȰb,
!Է!I]}"2?MGa
"%GWV>}U[sB-U=Mmމa׾ ^ 11	1%dsZjK';}l@=% uEU$KJDA[hD'*黹m_"u8M&3.@MoZ伪6XC|Dȃ*4LMH2^`lņDllv:ͻH*&0.-XizzӶ,L\UЮozhkWjB| '܍]ZX!4N0]q--\f$Zyul_ҫq<+b!w{N},QI~}>s
o?Wj sg}҈v٤+ٙ^*0Umߑr4Fm0]qspz%}N
B0do,?fF[ڷ~wA8{e@(-&*b<n,Aw(bFcШ*h[!ztOq5 Xn]Ǩ>r2!Q ='-ʘl]sf4[Vy.h@"& u׀p+!aՋ,.HQQ6cf3@/EO+r^}DORSX޺YqPU;oRzݣ<'f
LC}"4@(
	͑׸v QbAFC$q&'0

K@m圶!0an=ۗժYYnY$y)Vs)WЂ"0(+׃?%k&?4d%#*ҝ&	c,UOHMpw'}9Gq_}uz~Le 0
GZMd\{+u;|Fyyt'[_
'm.*X\3th¢[9%2hD&Jp`oB8`oLr3;eGzh 10vOY^c20RmC$f7BSNofU#|':.uYxhv.gjupþ͠%VLM2jh_PBųueg3-DǗq+W!W+Q7)MO93LuR+Fo{GSf=`#]˱HB,CN~4{~:xR]/e?K=bPbD}wRw#j'6w^ag^ֹQ*Nl`amwT;&2o43}~,|}'¶r<
C886Sb{'/u+;%n?9ҳ积Oί_.C"]+mMFDչldgC]0/`k+d`db*3d-7ܞVզ4+Ք(m|W	!ms6w1I]/I	f?-x
w'zyq$?5%N0wOTf"l.E?lGdD(֞>B
ߐL~/L6.:z!+9uݲp06:Z35:	wy67ue$,o
AwyTdc2$$)`@vY!>Y!{s|~RjFp"/`(mG\~Pm-nemjw:ZcT_{AQV,"0P*ؿ[Yq+MApΔߺsݥN$=K3ycme_.HMZ?nAԙ\F-gwxOg
-DͮwiȊe%1ֵ@dh>:2qb0
 
+l[ZpYi+i-T
%by9}< E^M v+~*znX,;a-7f>mV<'Q|un[evmjj2e#xI)G}U(euckSqx|h^Ucg5J-IMQJz9whoCEc>?9 ۭk"||nqG"MaPs"Q(3$HhYyUչ?}Uhz˲rZ;z:<ksvd>$j`ݝK=djuоd`+Ml1.z$N[:IC!Hov0YHYOp	"0މ`-nAb|p3C錼z8N_z4}smuqe䔻j/}EC2Ga)bIpIսjZ>"
պU6d-%[YuRn5E֐qukւ[2"GN&M wwwV׃8{,63
+.ִj7װ_El-aH+Y{z'~g	ύBzîk ՚ Sߵ/:v薛"WXɁ#V^_qֽ+v;qOsȁjLCg^W7d݌ȣ7GF>!9hRaR#-?lS
Uv%ycj
SaA!ww |uǟp'I}.vpޫW'A׌g×»K>IjЎ	
U<b5][B&ۜХUn '$cPHxWS|6x";Y<q(m	;w`kpG$ylmy+;98pF	@u1J??*t9ꕮw(cFtH6
?1vߜ=,+hPE%2:0p"Zn$ɕZ}N6Xm+ ]<+m`FgչE{Q_bZ6ЖUw{K>R&|Y,P,SN%
"ǦW%" N&ؐ{ƈz"ȔWjQ/qd̨{7wċ{!3\V́IRSH.rt	׳T&JR1=	7ŲvJ9`^XZ
<^/kxN3ɍZ߾zl 7b;ГC 6:18jyP\FiW'Vͺ}6W2Կ	IORoo/޾IϏ_gK5EJn!@^Ƥhz	GGm]*cݯyKp޲Yʑ>Jl(|
ҖA(NͭmܻTMiv?=(cY^ͻ
Q4OU:/.Ȏ;={^]<ښ	'GK_/E
|xuιrr5[c8yGÜK.r_F∿#iv_먊,copΣRiV|Zq]yWsc"H8̸ԻwΫNV{owiagQh`"~%O54V|ck̤N~(tW:扼֒}9YӬGO
擪O_?h프֋o?F"oț|%hão=iL e-bWUoϪr	@~4M-'(WI }ï=ƷZ<:OzLl`UqRg>qol7GO3l7O&Dn:=	',=84xt+uy8ٕǏXJǇNxSI%H\>!&6<M|
iE,L5                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Z[S7cy	d`
v:pii6NFʶ]iՂ_ߣ˂
FRı˧|:WՀ?؀JhW(5Wʚ	o}HQk))W+;Ab jD᧳ߠQ`Q\UH3`^Q#Je#ȨTq$ST2PQ/DSkDJ+"%RCQM$C`g.@ID4<7o) 
m(	W!V]5jVߡ`YmZ! 4ƣe=r4$Q^
Ӱl.B
0wVU-
;c7{ej\Z>
.ifЗOjP <XU$ 3F֌hr$[,Fm4o*霞|<:ؼ<>~<C5eEY8ƝRX|q
qtώ.)wrw9M; -S$iM~O	"CWxg/'OYLT5EGp
+sژa\c̦ǝs7g"+璕DN1^=&
oU
}Qu:5YΛ9J;?)6*ۚ	6NqJRvlriA[I ޜ	[?98M7USc^i^7M_M!s(+5;+),Y+ ݝud-jcŴiVdmYVX
)\>}ԹzqzKefU!dg%RVc8]Df2gׁذȰ^%@xL}@ޮZ\bLGLbڃ@;vs2Ad6ceFm;2OD9FRtӶҲR %i5r@cD,i~UŬJػw@9EOH*k
xBvh@:"K.LL봵VKIT%olr!Gt/ө#r 6lFZfAI㙜ΘMm=EQ՞NQ_Q}ǤV*&01q:YS<ݦM.qؐIRc$I6NOv-PI^N+Q7~ d1899Q8s
4ޔa&2a3\δDTÓg'Uq Ю-v$
tNh;
[ V(:C-+83ev,B@n +E_뚠ri><dw-j=?JVSEpT/_ns'B	.:^NbŎy:֯
ݣrL\9?KB+STm\ #;g:F1Cwji-_zjSIݞcp!ή5߆E5оmuOg=Ppnƻ2׶Q43J6@;ı;3Hy⣴nyN_-oyD
Ho
yǭdjppj<z8}|޳mr#
s/q ù3-0/P`7:HC8uN&TYAF
#L*OcM<5ኌ; GX7M-Qhd/QAPwoRzȳ¦wdyĦEZɸX.i8Wϲ9m Px]TkclQjI{OڪQ`gG3^\HXF>)U"ʨRi҆*U	%ra*]=.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       XKs8O,jN3[ޓǶf]YKIjO)H$)R5$@RvW*e~~VU֪Xb]~b{]\ŁēS,uʂ)[r^:L$d'FlU.,]	ϳskVo%+kjZIZj#HZ8zeKk
ԪZ	&KK;\`BX3Q%ZL*1ƮAͶf_xgldr]-ٴl*c_$mEQ#uɖTUkhjIZfʕZZ	6Ì]5Qc4J;E%?Bu>#8\@sYڶ"#Z!f/޲>Xfri,곫\8}˧!KkTjO>S2oVP!Q1>voj~p%*&QoMtb&.^Fq&4'7קU=K)GXPދHs%R፸gZa`	$a8K	QfbnI{zSeN߱txg{ǄGZgq܏7bbˋr\m-jG?͒|,(E1I;>,J@j׽R#$kR7
w܋<8 /)"j)JxL=ٴ,뢬?4Lbjr8:MEUxfRqfMm%e+%aرܩ:I4;%0R?/GUwoeġzQ88HBn*w{ H7Z`zOAh#=? a6/0ugTI{
If_*5YܧRPrWc]N=-RGμq48{v[P4zÄ TKqp듩QD$㐖xqWm~>_-PH8$e #bEB~-eH v@U&IDׄ|CZ`b<>zmj
<t>6 @ &Γqjk(qgעk
XTiq+`~$5I9w	 vXa^0%])Hsqfw4zH3{x:l^g6RH[%<GH/_Tρ'FFA'.[FQtJ<<{r~lJ>3{4ɬUqߊġYz{aj/p ԕ>lgFl$ZS'&rc3fXpjfxwņ8f{TH1=¢St*
|Al!wH&NTO=h4v,AC
 Kࠊ}S͉ RhI`&LW0y^\br-2MF#`GFC߀&GL(='#Lߑe^fɒ#/q=Jl&@ՖFUSW&^d	YÊf3	X1Rqf_bQԗɅIڙSBۃ.zJV`Xzn-}\Y2k6Mtb:wR!SUڈ~Ԙ:N(띸ZT:N~*
 l(zB3Pa2=zCukh6Z7|-u*&4sE$Hߐ]W3GX;3I:0v7lqN:%Ve&Zq>l82ã`Ƨ:[ɵ 0]d'wbY}ȌA͙xy=
 ryh/+DZ?$X+84!53+ŇR;5J󍾠,e|¬v;ܞs%
}K}풪eeF#b@,@aRpU.)ݯ{JkMMk8~?Uݔv~[lg$OBIRah5fXldfQɚc1XJ%򹭭k;TzVSζxqGr 
ZOXLy֣;,sz
=?&
g@ꏟq_4;hdyJľ[JldKөHц;¤G䩫FkR
"
pc->=|ǹ]G&ϭZkt+1$aX;6Q,e?
'!|{_=\"礏⾟xV{`!o'AtOmG)V/{kڍxj?baLo.8\})l. \$eE1w#p@Q}AG;G;WdY.XSR⿘i(                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               	     $     =     Y     j                           !                       .     A     `     w            "     -         )     &     *           3     5   E  2   {  $               @     "   ,  &   O  .   v       /     ,     )   "     L     a  ^   r  U              
                          	                                     
                              %s terminated by signal %d %s: stopped by signal %d %s: terminated by signal %d < %s ... %s > ?  argument line too long argument list too long cannot fork command too long days double environment is too large for exec error waiting for %s invalid -size type `%c' invalid argument `%s' to `%s' invalid expression invalid null argument to -size invalid predicate `%s' missing argument to `%s' single unknown warning: unrecognized escape `\%c' warning: unrecognized format directive `%%%c' Project-Id-Version: findutils 4.1.7
Report-Msgid-Bugs-To: bug-findutils@gnu.org
PO-Revision-Date: 2003-11-04 05:21+0200
Last-Translator: Ales Nyakhaychyk <nab@mail.by>
Language-Team: Belarusian <i18n@mova.org>
Language: be
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Bugs: Report translation errors to the Language-Team address.
X-Generator: KBabel 1.0.2
 %s завершаны сыгналам %d %s: спынена сыгналам %d %s: пярэрвана сыгналам %d < %s ... %s > ?  сьпіс довадаў занадта доўгі сьпіс довадаў занадта вялікі немагчыма нарадзіць працэс загад занадта доўгі дзён двайныя асяродзьдзе занадта вялікае для exec памылка чаканьня %s нерэчаісны від -size "%c" нерэчаісны довад "%s" да "%s" нерэчаісны выраз нерэчаісны null-довад да -size нерэчаісны выказьнік "%s" прапушчаны довад да "%s" адзінарныя невядома увага: нераспазнаная службовая пасьлядоўнасьць "\%c" увага: нераспазнанае прадпісаньне фармату "%%%c"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                0   X                             A     :     O     B   _          v  3   W  }     I   	  L   S                 O     >        M  I   "  D   l  E     H     7   @  "   x  '     |        @  $   [                           #          $   3  !   X  !   z  -          !     &     4   3      h  <          >             ,  +   L     x  @     $          "         :      T      g         I   !  9   !  #   7"  8   ["  1   "     "      "  <   #  b   A#  b   #  c   $     k$     $     
%     %  N   &%  >   u%  t   %     )&  1   A&  6   s&  7   &  g   &  4   J'  M   '  +   '  3   '  W   -(  x   (     (  ?   )     \)  X   *  <   a*  )   *  "   *     *  3   +  6   ,  9   Q,  (   ,     ,  ,   F-     s-  D   .  &   ].     .  7   .  -   .    /  0   0  *   0     1  /   1  *   1  A   1  o   )2  q   2  :   3     F3     3     	4  7    4  =   X4  C   4  3   4     5  :   5     Z5     f5     w5  !   5     5     5  !   5  Y   5     26     O6     d6  !   6  =   6  !   6  +   7  -   27     `7      7      7  #   7  6   7  %   8  '   C8     k8     8     8     8  P   8  6   9  )   R9  P   |9     9     9  3   9     0:  D   G:  (   :     :     >;     W;  )   m;  %   ;      ;  8   ;     <  6   1<     h<  *   o<     <     <     <     <     <     =     !=     )=  W   @=  ?   =  .   =  H   >  :   P>  q   >  >   >  o   <?  "   ?  -   ?  @   ?     >@      A     ,A    BA  ;  B  q   ,D  Y   D     D     E  O  JF    G  @   I     I     J     VK    L     M    gN     O     8P  4  P     R  s   R  i   ?S     S  \   4T  0   T  @   T     U  7   U  P   U  %   HV  -   nV     V  +   V  H   V  d   "W  A   W  q   W  m   ;X  m   X  c   Y  ?   {Y  =   Y  R   Y  n   LZ  ;   Z  }   Z     u[     [  )   \  P   8\  n   \  D   \     =]  _   ]  P   *^  L   {^  P   ^  %   _  F  ?_  `  `     a  p   ~b  p   b  z   `c  [   c  ?   7d  A   wd     d     Xe     Rf     Mg    (h  <   -i     ji     yi     i     ?j     j  1   nk  b   k     l  a   l     l  d   m  g   )n  ]   n     n     wo     <p  5   q     8q  ~  q     =s  n   s  L   Mt  h   t    u  a   v  d   v  h   Xw  B   w     x  T   x  (  Iy     rz  K   z  6   H{  m   {  8   {    &|  c   }  M   C~    ~  v     P        h          ݁  z     -  *  ;   X  A     l   ք  ~   C  w        :  -          B     .   ȇ  3     t   +            E          @   ĉ  4     G   :  C     }   Ɗ  5   D  B   z  Y     P     Z   h  d   Ì  E   (     n  Z     `   J  A     5     <   #     `       Y   1  J        ֐  (   r  C     U   ߑ  .   5     d  U        ]  -   -  /   [  c     3     .   #  ]   R  /             a  S   r  !   Ɩ       M     C   V  <     E   ח       *   .     Y  r     i   q     ۙ     j               2  C     Y   H         6       &        9              z   #                              ^   6       $   G      Z   0   '   \   x                       ?   %   3                         +                r          ,   T   *       C   b   .   S       w   >      I      &       
       p   8         s   H       o                          7   M       d   1      y          X   Q   U   h   (          O       ]                                       e                     A             i          m       V      ;   2                               f            B             l   J   )   n   j              :      {   L       [   D   K              c   F   /   W                           R   
      a   !   }   Y       @                   ~      4   q       P              `       t                                                       =   "                 g                                         5   u          E                          v            <   N          |             k         -             _           	      +        0  D  X  l            3  $          _  5            H            2            /          E  7          ~  E       
   С            T              n          ^  m          ͣ  n           
Execution of xargs will continue now, and it will try to read its input and run commands; if this is not what you wanted to happen, please type the end-of-file keystroke.
 
Use '-D help' for a description of the options, or see find(1)

       --help                   display this help and exit
       --process-slot-var=VAR   set environment variable VAR in child processes
       --show-limits            show limits on command-line length
   -0, --null                   items are separated by a null, not whitespace;
                                 disables quote and backslash processing and
                                 logical EOF processing
   -E END                       set logical EOF string; if END occurs as a line
                                 of input, the rest of the input is ignored
                                 (ignored if -0 or -d was specified)
   -I R                         same as --replace=R
   -L, --max-lines=MAX-LINES    use at most MAX-LINES non-blank input lines per
                                 command line
   -P, --max-procs=MAX-PROCS    run at most MAX-PROCS processes at a time
   -a, --arg-file=FILE          read arguments from FILE, not standard input
   -d, --delimiter=CHARACTER    items in input stream are separated by CHARACTER,
                                 not by whitespace; disables quote and backslash
                                 processing and logical EOF processing
   -e, --eof[=END]              equivalent to -E END if END is specified;
                                 otherwise, there is no end-of-file string
   -l[MAX-LINES]                similar to -L but defaults to at most one non-
                                 blank input line if MAX-LINES is not specified
   -n, --max-args=MAX-ARGS      use at most MAX-ARGS arguments per command line
   -p, --interactive            prompt before running commands
   -r, --no-run-if-empty        if there are no arguments, then do not run COMMAND;
                                 if this option is not given, COMMAND will be
                                 run at least once
   -s, --max-chars=MAX-CHARS    limit length of command line to MAX-CHARS
   -t, --verbose                print commands before executing them
   -x, --exit                   exit if the size (see -s) is exceeded
 %s is an slocate database of unsupported security level %d; skipping it. %s is an slocate database.  Turning on the '-e' option. %s is not the name of a known user %s is not the name of an existing group %s is not the name of an existing group and it does not look like a numeric group ID because it has the unexpected suffix %s %s terminated by signal %d %s: exited with status 255; aborting %s: stopped by signal %d %s: terminated by signal %d < %s ... %s > ?  All Filenames: %s
 Cannot close standard input Cannot obtain birth time of file %s Cannot open input file %s Cannot read mounted file system list Cannot set SIGUSR1 signal handler Cannot set SIGUSR2 signal handler Compression ratio %4.2f%% (higher is better)
 Compression ratio is undefined
 Database %s is in the %s format.
 Database was last modified at %s.%09ld Duplicate file type '%c' in the argument list to %s. Empty argument to the -D option. Environment variable %s is not set to a valid decimal number Eric B. Decker Expected a positive decimal integer argument to %s, but got %s Expected an integer: %s Failed to fully drop privileges Failed to initialize shared-file hash table Failed to read from stdin Failed to save working directory in order to run a command on %s Failed to write output (at stage %d) Failed to write prompt for -ok Failed to write to standard output Failed to write to stderr Features enabled:  File descriptor %d will leak; please report this as a bug, remembering to include a detailed description of the simplest way to reproduce this problem. File names have a cumulative length of %s bytes.
Of those file names,

	%s contain whitespace, 
	%s contain newline characters, 
	and %s contain characters with the high bit set.
 File system loop detected; %s is part of the same file system loop as %s. I cannot figure out how to interpret %s as a date or time Ignoring unrecognised debug flag %s In %s the %s must appear by itself, but you specified %s Invalid argument %s for option --max-database-age Invalid argument %s to -used Invalid argument `%s%s' to -size Invalid escape sequence %s in input delimiter specification. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lo. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lx. Invalid escape sequence %s in input delimiter specification; trailing characters %s not recognised. Invalid input delimiter specification %s: the delimiter must be either a single character or an escape sequence starting with \. Invalid optimisation level %s James Youngman Kevin Dalley Last file type in list argument to %s is missing, i.e., list is ending on: ',' Locate database size: %s byte
 Locate database size: %s bytes
 Mandatory and optional arguments to long options are also
mandatory or optional for the corresponding short option.
 Matching Filenames: %s
 Must separate multiple arguments to %s using: ',' Old-format locate database %s is too short to be valid Only one instance of {} is supported with -exec%s ... + Optimisation level %lu is too high.  If you want to find files very quickly, consider using GNU locate. Please specify a decimal number immediately after -O Run COMMAND with arguments INITIAL-ARGS and more arguments read from input.

 Security level %s has unexpected suffix %s. Security level %s is outside the convertible range. Some filenames may have been filtered out, so we cannot compute the compression ratio.
 Symbolic link %s is part of a loop in the directory hierarchy; we have already visited the directory to which it points. The %s test needs an argument The -O option must be immediately followed by a decimal integer The -delete action automatically turns on -depth, but -prune does nothing when -depth is in effect.  If you want to carry on anyway, just explicitly use the -depth option. The -show-control-chars option takes a single argument which must be 'literal' or 'safe' The argument for option --max-database-age must not be empty The argument to -user should not be empty The atexit library function failed The current directory is included in the PATH environment variable, which is insecure in combination with the %s action of find.  Please remove the current directory from your $PATH (that is, remove ".", doubled colons, or leading or trailing colons) The database has big-endian machine-word encoding.
 The database has little-endian machine-word encoding.
 The database machine-word encoding order is not obvious.
 The environment is too large for exec(). The environment variable FIND_BLOCK_SIZE is not supported, the only thing that affects the block size is the POSIXLY_CORRECT environment variable The input file should end with the delimiter The relative path %s is included in the PATH environment variable, which is insecure in combination with the %s action of find.  Please remove that entry from $PATH This system does not provide a way to find the birth time of a file. Try '%s --help' for more information.
 Unexpected suffix %s on %s Unknown regular expression type %s; valid types are %s. Usage: %s [-0 | --null] [--version] [--help]
 Usage: %s [-d path | --database=path] [-e | -E | --[non-]existing]
      [-i | --ignore-case] [-w | --wholename] [-b | --basename] 
      [--limit=N | -l N] [-S | --statistics] [-0 | --null] [-c | --count]
      [-P | -H | --nofollow] [-L | --follow] [-m | --mmap] [-s | --stdio]
      [-A | --all] [-p | --print] [-r | --regex] [--regextype=TYPE]
      [--max-database-age D] [--version] [--help]
      pattern...
 Usage: %s [OPTION]... COMMAND [INITIAL-ARGS]...
 WARNING: Lost track of %lu child processes WARNING: a NUL character occurred in the input.  It cannot be passed through in the argument list.  Did you mean to use the --null option? WARNING: cannot determine birth time of file %s WARNING: file %s appears to have mode 0000 WARNING: locate database %s was built with a different byte order Warning: %s will be run at least once.  If you do not want that to happen, then press the interrupt keystroke.
 You may not use {} within the utility name for -execdir and -okdir, because this is a potential security problem. You need to specify a security level as a decimal integer. You specified the -E option, but that option cannot be used with slocate-format databases with a non-zero security level.  No results will be generated for this database.
 argument line too long argument list too long argument to -group is empty, but should be a group name arithmetic overflow when trying to calculate the end of today arithmetic overflow while converting %s days to a number of seconds can't call exec() due to argument size restrictions cannot delete %s cannot fit single argument within argument list size limit cannot fork cannot search %s command too long could not create pipe before fork days double environment is too large for exec errno-buffer safe_read failed in xargs_do_exec (this is probably a bug, please report it) error reading a word from %s error waiting for %s error waiting for child process error: %s at end of format string error: the format directive `%%%c' is reserved for future use expected an expression after '%s' expected an expression between '%s' and ')' failed to compile regular expression '%s': %s failed to drop group privileges failed to drop setgid privileges failed to drop setuid privileges failed to open /dev/tty for reading failed to restore working directory after searching %s failed to set environment variable %s failed to unset environment variable %s getfilecon failed: %s invalid -size type `%c' invalid argument `%s' to `%s' invalid expression invalid expression; I was expecting to find a ')' somewhere but did not see one. invalid expression; empty parentheses are not allowed. invalid expression; you have too many ')' invalid expression; you have used a binary operator '%s' with nothing before it. invalid mode %s invalid null argument to -size invalid predicate -context: SELinux is not enabled. invalid predicate `%s' locate database %s contains a filename longer than locate can handle locate database %s is corrupt or invalid locate database %s looks like an slocate database but it seems to have security level %c, which GNU findutils does not currently support missing argument to `%s' no argument expected. oops -- invalid default insertion of and! oops -- invalid expression type (%d)! oops -- invalid expression type! option --%s may not be set to a value which includes `=' pattern argument expected sanity check of the fnmatch() library function failed. single slocate security level %ld is unsupported. standard error standard output time system call failed unexpected EOF in %s unexpected extra predicate unexpected extra predicate '%s' unknown unknown predicate `%s' unmatched %s quote; by default quotes are special to xargs unless you use the -0 option warning: -%s %s will not match anything because it ends with /. warning: escape `\' followed by nothing at all warning: format directive `%%%c' should be followed by another character warning: the -E option has no effect if -0 or -d is used.
 warning: the -d option is deprecated; please use -depth instead, because the latter is a POSIX-compliant feature. warning: the locate database can only be read from stdin once. warning: there is no entry in the predicate evaluation cost table for predicate %s; please report this as a bug warning: unrecognized escape `\%c' warning: unrecognized format directive `%%%c' warning: value %ld for -s option is too large, using %ld instead warning: you have specified a mode pattern %s (which is equivalent to /000). The meaning of -perm /000 has now been changed to be consistent with -perm -000; that is, while it used to match no files, it now matches all files. write error you have too many ')' Project-Id-Version: findutils 4.5.15
Report-Msgid-Bugs-To: bug-findutils@gnu.org
PO-Revision-Date: 2018-09-28 09:01+0200
Last-Translator: Alexander Shopov <ash@kambanaria.org>
Language-Team: Bulgarian <dict@ludost.net>
Language: bg
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Bugs: Report translation errors to the Language-Team address.
Plural-Forms: nplurals=2; plural=(n != 1);
 
Изпълнението на xargs ще продължи, като ще бъде направен опит да се четат командите.  Ако това не е каквото искате да се случи, въведете управляващия код за край на файл (Control-D).
 
За описание на опциите използвайте „-D help“ или вижте „find(1)“

       --help                   извеждане на тази помощ и изход
       --process-slot-var=ПРОМ  Задаване на ПРОМенливата на средата
                               за дъщерните процеси
       --show-limits            извеждане на ограниченията на размера на
                               командния ред
   -0, --null                   Записите са разделени с NULL, а не интервал.
                               Това изключва обработката на кавички, обратно
                               наклонени черти и логически край на файл (EOF)
   -E НИЗ                       НИЗ за логически край на файл (EOF).  Ако НИЗът
                               се появи самостоятелно на ред, останалата част
                               от входните данни се игнорират (тази опция не се
                               взима предвид, ако е зададена някоя от „-0“ или
                               „-d“)
   -I R                        същото като --replace=R
   -L, --max-lines=БРОЙ_РЕДОВЕ  ползване на максимално този БРОЙ_РЕДОВЕ,
                               които не са празни, за команден ред
   -P, --max-procs=БРОЙ_ПРОЦ    Стартиране на максимално такъв БРОЙ_ПРОЦеси
                               наведнъж
   -a, --arg-file=ФАЙЛ          Изчитане на аргументите от ФАЙЛа, а не
                               от стандартния вход
   -d, --delimiter=ЗНАК         Записите във входния поток са разделени с този
                               ЗНАК, а не интервал.  Това изключва обработката
                               на кавички, обратно наклонени черти и логически
                               край на файл (EOF)
   -e, --eof[=НИЗ]              Еквивалентно на -E НИЗ, ако е указан НИЗ.
                               Иначе няма низ за край на файл
   -l[БРОЙ_РЕДОВЕ]              същото като -L, ако е указан БРОЙ_РЕДОВЕ, в
                               противен случай означава максимално един
                               непразен ред
   -n, --max-args=БРОЙ_АРГ      Използване на максимално такъв БРОЙ_АРГументи
                               на команден ред
   -p, --interactive            изчакване на потвърждение преди изпълнение
                               на команди
   -r, --no-run-if-empty        ако няма аргументи, да не се изпълнява КОМАНДАта.
                               Когато тази опция не е зададена, КОМАНДАта се
                               изпълнява поне веднъж.
   -s, --max-chars=БРОЙ_ЗНАЦИ   ограничаване на дължината на командния ред до
                               този брой знаци
   -t, --verbose                извеждане на командите преди изпълнението им
   -x, --exit                   изход, ако размерът се надвиши (виж „-s“)
 %s е база от данни от тип slocate с неподдържано ниво на сигурност %d, пропуска се. %s е база от данни тип slocate.  Включва се опцията „-e“. няма потребител с име „%s“ „%s“ не е име на съществуваща група „%s“ не е име на съществуваща група и не изглежда като номер на група, защото има неочакван суфикс „%s“ „%s“ бе прекратен със сигнал %d %s: завърши с код 255. Прекратяване на работата %s: спрян със сигнал %d %s: прекратен със сигнал %d < %s … %s > ?  Всички файлови имена: %s
 Стандартният вход не може да се затвори Времето на създаване на файла „%s“ не може да се получи Не може да се отвори входният файл %s Списъкът с монтирани файлови системи не може да бъде прочетен Не може да се зададе функция за обработка на сигнала „SIGUSR1“ Не може да се зададе функция за обработка на сигнала „SIGUSR2“ Степен на компресия %4.2f%% (по-голямото число е по-добре)
 Степен на компресия: неопределена
 Форматът на базата от данни %s е %s.
 Базата от данни е променена последно на  %s.%09ld В списъка с аргументи на „%2$s“ се повтаря вида на файл „%1$c“. Празен аргумент за опцията „-D“. Стойността на променливата на средата „%s“ не e цяло десетично число Eric B. Decker Очаква се положително цяло десетично число като аргумент на „%s“, а не „%s“ Очаква се цяло число: %s Привилегиите не може да се анулират напълно Неуспешно инициализиране на речника за споделените файлове Неуспешно четене от стандартния вход Неуспешно запазване на текущата директория, за да се изпълни команда върху %s Неуспешно извеждане към стандартния изход на етап %d Неуспешно извеждане на подсказката за „-ok“ Неуспешно извеждане на стандартния изход Неуспешно извеждане на стандартната грешка Разрешени свойства:  Файловият дескриптор %d няма да бъде затворен — това е грешка и молим да я докладвате.  Включете и подробно описание на най-простия начин, който сте открили, за появата на проблема. Имената на файловете са с обща дължина от %s байта.

От тези имена на файлове:
 ⁃ %s съдържат интервали или други празни знаци;
 ⁃ %s съдържат знаци за нов ред;
 ⁃ %s съдържат знаци със зададен 8-и бит.
 Открит бе цикъл във файловата система — „%s“ е част от същото зацикляне като „%s“. Не е ясно как „%s“ може да се интерпретира като дата или време Непознатият флаг за изчистване на грешки „%s“ се пренебрегва „%2$s“ трябва да се появява самостоятелно в „%1$s“, а е указано „%3$s“ Неправилен аргумент „%s“ за опцията „--max-database-age“ Недопустим аргумент „%s“ за „-used“ неправилен аргумент „%s%s“ за „-size“ Неправилно екраниране с обратно наклонена черта %s в описанието на входния разделител. Неправилно екраниране с обратно наклонена черта %s в описанието на входния разделител — стойностите на знаците не може да превишават %lo. Неправилно екраниране с обратно наклонена черта %s в описанието на входния разделител —  стойностите на знаците не може да превишават %lx. Неправилно екраниране с обратно наклонена черта %s в описанието на входния разделител — крайните знаци %s не са познати. Неправилно описание на входния разделител %s: разделителят трябва да бъде или единичен знак, или екраниран знак с обратно наклонена черта „\“. Неправилно ниво за оптимизация %s James Youngman Kevin Dalley Последният вид файлове в списъка с аргументи на „%s“ липсва, т.е. списъкът завършва с „,“, а не трябва Размер на базата от данни на locate: %s байт
 Размер на базата от данни на locate: %s байта
 Аргументите са еднакво задължителни или не
както за дългите, така и за късите опции.
 Напасващи файлови имена: %s
 Аргументите на „%s“ трябва да се разделят със запетаи Старият формат на базата от данни %s на locate е твърде къс, за да бъде валиден С „-exec%s … +“ е позволено само едно използване на „{}“ Нивото за оптимизация %lu е твърде високо.  Ако желаете да намирате файлове още по-бързо, пробвайте програмата locate на GNU. Задайте десетично цяло число непосредствено след „-O“ Изпълнение на КОМАНДАта с тези ПЪРВОНАЧАЛНи_АРГУМЕНТи.

 Нивото на сигурност „%s“ е с неочакван суфикс „%s“. Ниво на сигурност „%s“ е извън диапазона, който може да бъде преобразуван. Някои файлови имена може да са били филтрирани, поради което не може да се пресметне степента на компресия.
 Символната връзка „%s“ е част от цикъл в йерархията директориите — сочената директория вече е обработвана. Тестът „%s“ изисква аргумент Опцията „-O“ трябва непосредствено да се следва от десетично цяло число. Действието „-delete“ (изтриване) автоматично включва „-depth“ (дълбочина), а „-prune“ (окастряне) не прави нищо, когато е използвана опцията „-depth“.  Ако все пак искате да продължите, изрично ползвайте опцията „-depth“. Опцията „-show-control-chars“ приема единствен аргумент, който трябва да бъде „literal“ или „safe“ Аргументът на опцията „--max-database-age“ не трябва да бъде празен Аргументът на „-user“ не трябва да е празен Грешка при изпълнението на библиотечната функция „atexit“ Текущата директория е включена в променливата от обкръжението PATH, което е несигурно при използване на действието „%s“ на find.  Извадете текущата директория от $PATH (т.е. премахнете „.“, „::“ или началните или крайни „:“) Базата от данни е с подредба на машинните думи big-endian.
 Базата от данни е с подредба на машинните думи little-endian.
 Подредбата на машинните думи в базата от данни не е ясен.
 Обкръжението е твърде голямо за exec(). Променливата на средата „FIND_BLOCK_SIZE“ не се поддържа.  Единственото нещо, което влияе на размера на блока, е променливата „POSIXLY_CORRECT“ Входният файл трябва да завършва с разделител Относителният път „%s“ е включен в променливата от обкръжението „PATH“, което е несигурно при използване на действието „%s“ на find.  Извадете този елемент от „$PATH“ Тази система не предоставя начин да се намери времето на създаване на файл. За повече информация изпълнете „%s --help“.
 Непознат суфикс „%s“ при „%s“ Непознат вид регулярен израз „%s“.  Позволените видове са %s. Употреба: %s [-0 | --null] [--version] [--help]
 Употреба: %s [-d ПЪТ | --database=ПЪТ] [-e | -E | --[non-]existing]
      [-i | --ignore-case] [-w | --wholename] [-b | --basename] 
      [--limit=N | -l N] [-S | --statistics] [-0 | --null] [-c | --count]
      [-P | -H | --nofollow] [-L | --follow] [-m | --mmap ] [ -s | --stdio ]
      [-A | --all] [-p | --print] [-r | --regex ] [--regextype=ВИД]
      [--max-database-age D] [-version] [--help]
      ШАБЛОН…
 Употреба: %s [ОПЦИЯ]… КОМАНДА [ПЪРВОНАЧАЛЕН_АРГУМЕНТ]…
 ВНИМАНИЕ: %lu дъщерни процеси бяха загубени ВНИМАНИЕ: от входа бе прочетен нулев знак (NUL).  Той не може да бъде предаден в списъка на аргументите.  Може би ще искате да използвате опцията „--null“. ВНИМАНИЕ: времето на създаване на файла „%s“ не може да се получи ВНИМАНИЕ: файлът „%s“ е с права на достъп: 0000 ВНИМАНИЕ: базата от данни на locate %s е изградена с друга подредба на машинната дума ВНИМАНИЕ: %s ще се изпълни поне веднъж.  Ако не искате това да се случва, натиснете управляващия символ за прекъсване (Control-C).
 Не може да използвате „{}“ при името на команда за „-execdir“ и „-okdir“, тъй като това създава проблем със сигурността. Трябва да укажете нивото на сигурността като цяло десетично число. Посочили сте опцията -E, но тя не може да се използва при база от данни тип slocate с ненулево ниво на сигурност.  Няма да бъдат генерирани резултати от тази база от данни.
 редът с аргументи е твърде дълъг списъкът с аргументи е твърде дълъг аргументът на „-group“ е празен, а трябва да бъде име на група аритметично препълване при опит да се пресметне краят на днешния ден аритметично препълване при преобразуване на %s дни в брой секунди exec() не може да се изпълни поради ограничение на размера на аргументите „%s“ не може да се изтрие един аргумент не може да се смести в ограничението на размера на списъка с аргументи не може да се създаде нов процес с fork в „%s“ не може да се търси командата е прекалено дълга преди разклоняването на процеса не бе създаден програмен канал дена Двойна обкръжението е твърде голямо за „exec“ неуспешно изпълнение на „safe_read“ за „errno-buffer“ в „xargs_do_exec“ (най-вероятно това е грешка, молим да я докладвате) грешка при изчитане на дума от „%s“ грешка при изчакване на „%s“ грешка при изчакване на дъщерен процес ГРЕШКА: „%s“ в края на форматиращ низ ГРЕШКА: форматиращата директива „%%%c“ е запазена за бъдеща употреба след „%s“ трябва да има израз между „%s“ и „)“ трябва да има израз регулярният израз „%s“ не може да се компилира: %s не може да се анулират груповите привилегии не може да се анулират привилегиите за група (setgid) не може да се анулират привилегиите на потребител (setuid) „/dev/tty“ не може да се отвори за четене Неуспешно връщане към първоначалната директория след търсене на „%s“ променливата на средата „%s“ не може да се зададе променливата на средата „%s“ не може да бъде изтрита неуспешно изпълнение на „getfilecon“: %s неправилен вид „%c“ на „-size“ неправилен аргумент „%s“ за „%s“ неправилен израз неправилен израз — очакваше се някъде да се срещне затваряща скоба „)“, но такава не бе открита. неправилен израз — празни скоби не са позволени. неправилен израз — има твърде много „)“ неправилен израз — използвали сте двуместният оператор „%s“, а преди него няма нищо. неправилен режим „%s“ недопустим празен аргумент на „-size“ неправилен предикат „-context“ — SELinux е изключен. неправилен предикат „%s“ базата от данни на locate (%s) съдържа файлово име, по-дълго от това, с което locate може да работи базата от данни %s на locate е повредена или грешна базата от данни на locate (%s) изглежда от тип slocate, но има ниво на сигурност %c, което в момента не се поддържа от GNU findutils липсващ аргумент за „%s“ не трябва да има аргумент. Неправилно вмъкване по подразбиране на оператор „И“! Неправилен вид на израза (%d)! Неправилен вид на израза! аргументът на опцията „--%s“ не може да съдържа „=“ очаква се аргумент-шаблон проверката на библиотечната функция „fnmatch()“ за правилност пропадна.  Единична ниво на сигурност %ld на „slocate“ не се поддържа. стандартна грешка стандартен изход неуспешно извикване на функцията за време неочакван знак за край на файл в „%s“ неочакван допълнителен предикат неочакван допълнителен предикат „%s“ непознат непознат предикат „%s“ %s кавичка без еш.  Стандартно кавичките са специални за xargs, освен ако използвате опцията -0 ВНИМАНИЕ: „-%s %s“ няма да напасне с нищо, защото завършва с „/“. ВНИМАНИЕ: екраниращият знак „\“ не е следван от друг знак ВНИМАНИЕ: форматиращата директива „%%%c“ трябва да е следвана от още един знак ВНИМАНИЕ: опцията „-E“ не прави нищо, ако е ползвана опцията „-0“ или „-d“.
 ВНИМАНИЕ: опцията „-d“ е остаряла, вместо нея използвайте „-depth“ както е според стандарта POSIX. ВНИМАНИЕ: базата от данни на locate може да се чете от стандартния вход само веднъж. ВНИМАНИЕ: в таблицата за цената на предикатите липсва запис за предиката „%s“. Това е грешка, молим да я докладвате ВНИМАНИЕ: непознато екраниране „\%c“ ВНИМАНИЕ: непозната форматираща директива „%%%c“ ВНИМАНИЕ: стойността %ld за опцията „-s“ е твърде голяма, вместо нея се използва %ld ВНИМАНИЕ: посочили сте образец за режим за достъп „%s“, който е еквивалентен на „/000“.  Смисълът на „-perm /000“ бе променен да отговаря на „-perm -000“, т.е. докато в миналото на него не пасваше нито един файл, в момента му пасват всички файлове. грешка при запис има твърде много „)“ PRIuMAX Your environment variables take up % bytes
 POSIX upper limit on argument length (this system): %
 POSIX smallest allowable upper limit on argument length (all systems): %
 Maximum length of command we could actually use: %
 Size of command buffer we are actually using: %
 Maximum parallelism (--max-procs must be no greater): %
 Променливите на обкръжението заемат % байта
 Горна граница на дължината на аргументите според POSIX при тази система: %
 Най-малка долна граница на дължината на аргументите при всички системи според POSIX: %
 Максимална дължина на командата, която може да се използва: %
 Размер на командния буфер, който действително се използва: %
 Максимален паралелизъм („--max-procs“ трябва да е не повече от): %
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        -        =                $        !     :     V  !   g       <     b     b   <  c          7          q   N                                !        9     N     n            P     )   	     2	     Q	     h	  )   	  %   	      	  6   	     )
     0
     K
  W   S
  q   
  >     "   \  -     v       $
  %   @
     f
     
     
  )   
     
  ]   
     T          r       8          ~                  >     U     h     m  )   s       !     "     ,        /  X   E  .     (                3   6  /   j  *     N          (     
   D     O       ^   d  4     1           -      %          "                
              *             !                 ,   +                                           )                    #       (       &            
   '   	                 $    %s terminated by signal %d %s: exited with status 255; aborting %s: stopped by signal %d %s: terminated by signal %d < %s ... %s > ?  Database %s is in the %s format.
 Features enabled:  Invalid escape sequence %s in input delimiter specification. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lo. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lx. Invalid escape sequence %s in input delimiter specification; trailing characters %s not recognised. Invalid input delimiter specification %s: the delimiter must be either a single character or an escape sequence starting with \. Only one instance of {} is supported with -exec%s ... + The environment variable FIND_BLOCK_SIZE is not supported, the only thing that affects the block size is the POSIXLY_CORRECT environment variable You may not use {} within the utility name for -execdir and -okdir, because this is a potential security problem. argument line too long argument list too long cannot fork command too long days double environment is too large for exec error waiting for %s error waiting for child process invalid -size type `%c' invalid argument `%s' to `%s' invalid expression invalid expression; I was expecting to find a ')' somewhere but did not see one. invalid expression; you have too many ')' invalid null argument to -size invalid predicate `%s' missing argument to `%s' oops -- invalid default insertion of and! oops -- invalid expression type (%d)! oops -- invalid expression type! sanity check of the fnmatch() library function failed. single unexpected extra predicate unknown unmatched %s quote; by default quotes are special to xargs unless you use the -0 option warning: the -d option is deprecated; please use -depth instead, because the latter is a POSIX-compliant feature. warning: the locate database can only be read from stdin once. warning: unrecognized escape `\%c' warning: unrecognized format directive `%%%c' Project-Id-Version: findutils 4.2.27
Report-Msgid-Bugs-To: bug-findutils@gnu.org
PO-Revision-Date: 2006-05-20 14:54+0200
Last-Translator: Jordi Mallach <jordi@gnu.org>
Language-Team: Catalan <ca@dodds.net>
Language: ca
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8-bit
X-Bugs: Report translation errors to the Language-Team address.
 %s finalitzat pel senyal %d %s: ha acabat amb estat 255; avortant %s: interromput pel senyal %d %s: terminat pel senyal %d < %s ... %s > ? La base de dades %s és en el format %s.
 Funcionalitats habilitades:  La seqüència d'escapament %s és il·legal en una especificació de delimitació d'entrada. La seqüència d'escapament %s és il·legal en una especificació de delimitació d'entrada; els valors dels caràcters no han d'excedir %lo. La seqüència d'escapament %s és il·legal en una especificació de delimitació d'entrada; els valors dels caràcters no han d'excedir %lx. La seqüència d'escapament %s és il·legal en una especificació de delimitació d'entrada; no es reconeixen el caràcters finals %s. La seqüència d'escapament %s és il·legal en una especificació de delimitació d'entrada: el delimitador ha de ser un únic caràcter o una seqüència d'escapament que comence amb \. Només es suporta una instància de {} amb -exec%s ... + La variable d'entorn FIND_BLOCK_SIZE no està suportada, l'única cosa que afecta a la mida dels blocs és la variable d'entorn POSIXLY_CORRECT No pdeu utilitzar {} dins del nom de la utilitat per a -execdir i -okdir, ja que això és un problema de seguretat potencial. línia d'arguments massa llarga llista d'arguments massa llarga no es pot fer «fork» ordre massa llarga dies doble l'entorn és massa gran per a l'execució error a l'esperar al procés %s error a l'esperar al procés fill el tipus de -size «%c» no vàlid l'argument «%s» no és vàlid per a «%s» expressió no vàlida l'expressió no és vàlida; s'esperava un «)» en algun lloc però no s'ha trobat cap. l'expressió no és vàlida; teniu massa «)» l'argument nul no és vàlid per a -size el predicat «%s» no és vàlid manca un argument per a «%s» oops -- inserció per defecte d'«and» no vàlida! ep -- el tipus d'expressió (%d) no és vàlid! ep -- el tipus d'expressió no és vàlid! la comprovació de sanitat de la funció fnmatch() de la biblioteca ha fallat. simple s'ha trobat un predicat extra no esperat desconegut s'ha trobat una cometa %s no emparellada. Per defecte, les cometes són especials per a xargs a no ser que s'utilitze l'opció -O avís: l'opció -d està desaconsellada; si us plau, utilitzeu -depth en el seu lloc, ja que aquesta és una funcionalitat que compleix amb POSIX. avís: la base de dades de locate només es pot llegir una vegada des de l'entrada estàndard. avís: seqüència d'escapament «\%c» no reconegut avís: directiva de format «%%%c» no reconeguda                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             0                   ,      4     5  :     O     B   m            3   e  }     I     L   a               -  O     >        [  I   0  D   z  E     H     7   N  "     '     |        N  $   i                           #        '  $   A  !   f  !     -          !     &         A  <   b       >               +   %     Q  @   k  $          "             -     @       I      9      #   !  8   4!  1   m!     !      !  <   !  b   "  b   }"  c   "     D#     #     #     #  >   #  t   >$     $  6   $  7   %  g   :%  4   %  M   %  +   %&  3   Q&  W   &  x   &     V'  ?   t'     '  X   `(  <   (  )   (  "    )     C)  3   >*  6   r*  9   *  (   *     +     +  D   C,     ,  7   ,  -   ,    	-  0   .  *   .     /  /   /  *   /  A   /  o   -0  q   0  :   1     J1     1     
2  7   $2  =   \2  C   2  3   2     3  :   #3     ^3     j3     {3  !   3     3     3  !   3  Y   3     64     S4     h4  !   4  =   4  !   4  +   
5     65      V5      w5  #   5  6   5  %   5  '   6     A6     W6     o6     6  P   6  6   6  )   (7  P   R7     7     7  3   7     8  D   8  (   b8     8     9  )   -9  %   W9      }9  8   9  6   9     :  *   :     @:     O:     _:     w:     :     :     :     :  W   :  ?   >;  .   ~;  H   ;  :   ;  q   1<  >   <  o   <  "   R=  -   u=  @   =     =     >     >    >     @  C   A     A  T   bB     B  /  C  8   D      E  K   E  v   E     `F     MG     H     H  I   LI     I  X   uJ  L   J  N   K  U   jK  8   K  $   K  $   L     CL     L  $   L     
M     )M     CM     TM  !   rM  *   M  #   M  ?   M  '   #N  '   KN  3   sN  #   N      N  -   N  #   O  H   >O     O  R   O     O      
P  6   +P  '   bP  P   P  &   P     Q  $   Q  -   DQ     rQ     Q     %R  j   R  /   KS  +   {S  9   S  4   S     T  &   5T  @   \T  h   T  h   U  j   oU  ~   U  "   YV     |V     V  n   V     W  $   W  V   W  9   X  y   IX  5   X  t   X  :   nY  8   Y  a   Y  |   DZ     Z  T   Z     1[     [  >   [\  4   \  !   \    \  ?   ]  >   >^  7   }^  +   ^     ^     v_  H   `  !   ``  =   `  /   `    `  @   b  "   b     b  7   ~c  +   c  B   c  s   %d     d  F   e     ee  )   .f  &   Xf  E   f  F   f  H   g  B   Ug     g  M   g     g     h     &h  )   Dh     nh     sh  )   |h  v   h     i     <i  &   Wi  -   ~i  M   i     i  *   j  !   Dj      fj      j  -   j  F   j  ,   k  0   Jk     {k      k  '   k     k  W   k  5   Dl  #   zl  `   l     l  %   m  3   7m     km  [   m  4   m     n     n  9   n  %   n      o  B   8o  :   {o     o  6   o     o     p     *p     Hp  %   ap  .   p  	   p     p  y   p  1   Wq  ?   q  Z   q  A   $r     fr  K   r     2s  -   s  <   s  S   #t     wt  
   [u     iu           O             $                                      w             >   u   d                    -            Y       i         j            +   y                     G   
                 e   ;                              =          Z                h         	         E   *                 I   x      W   k             "   
                          r   2      S   [   @      9   D              .              8      '   )      `                                           B      g       C   m         q          0      6       X      b       #   z   s   %   p       N   F   H       _   ?      ]          c   5              l   7   A                  1             M   V   L   P       |                        \   }   R      K   :   <       o           3   n   {                                   /                                      T   ^          U   Q   ,      f   &   J                  v   !      4                      t   ~       (       a      {u  D  X  l                     u  $          u  5          u  H          0v  2          dv  /          v  7          v  *       	   w  :          =w  R          w  ?          w  8          x  ?           
Execution of xargs will continue now, and it will try to read its input and run commands; if this is not what you wanted to happen, please type the end-of-file keystroke.
       --help                   display this help and exit
       --process-slot-var=VAR   set environment variable VAR in child processes
       --show-limits            show limits on command-line length
   -0, --null                   items are separated by a null, not whitespace;
                                 disables quote and backslash processing and
                                 logical EOF processing
   -E END                       set logical EOF string; if END occurs as a line
                                 of input, the rest of the input is ignored
                                 (ignored if -0 or -d was specified)
   -I R                         same as --replace=R
   -L, --max-lines=MAX-LINES    use at most MAX-LINES non-blank input lines per
                                 command line
   -P, --max-procs=MAX-PROCS    run at most MAX-PROCS processes at a time
   -a, --arg-file=FILE          read arguments from FILE, not standard input
   -d, --delimiter=CHARACTER    items in input stream are separated by CHARACTER,
                                 not by whitespace; disables quote and backslash
                                 processing and logical EOF processing
   -e, --eof[=END]              equivalent to -E END if END is specified;
                                 otherwise, there is no end-of-file string
   -l[MAX-LINES]                similar to -L but defaults to at most one non-
                                 blank input line if MAX-LINES is not specified
   -n, --max-args=MAX-ARGS      use at most MAX-ARGS arguments per command line
   -p, --interactive            prompt before running commands
   -r, --no-run-if-empty        if there are no arguments, then do not run COMMAND;
                                 if this option is not given, COMMAND will be
                                 run at least once
   -s, --max-chars=MAX-CHARS    limit length of command line to MAX-CHARS
   -t, --verbose                print commands before executing them
   -x, --exit                   exit if the size (see -s) is exceeded
 %s is an slocate database of unsupported security level %d; skipping it. %s is an slocate database.  Turning on the '-e' option. %s is not the name of a known user %s is not the name of an existing group %s is not the name of an existing group and it does not look like a numeric group ID because it has the unexpected suffix %s %s terminated by signal %d %s: exited with status 255; aborting %s: stopped by signal %d %s: terminated by signal %d < %s ... %s > ?  All Filenames: %s
 Cannot close standard input Cannot obtain birth time of file %s Cannot open input file %s Cannot read mounted file system list Cannot set SIGUSR1 signal handler Cannot set SIGUSR2 signal handler Compression ratio %4.2f%% (higher is better)
 Compression ratio is undefined
 Database %s is in the %s format.
 Database was last modified at %s.%09ld Empty argument to the -D option. Environment variable %s is not set to a valid decimal number Eric B. Decker Expected a positive decimal integer argument to %s, but got %s Expected an integer: %s Failed to fully drop privileges Failed to initialize shared-file hash table Failed to read from stdin Failed to save working directory in order to run a command on %s Failed to write output (at stage %d) Failed to write prompt for -ok Failed to write to standard output Failed to write to stderr Features enabled:  File descriptor %d will leak; please report this as a bug, remembering to include a detailed description of the simplest way to reproduce this problem. File names have a cumulative length of %s bytes.
Of those file names,

	%s contain whitespace, 
	%s contain newline characters, 
	and %s contain characters with the high bit set.
 File system loop detected; %s is part of the same file system loop as %s. I cannot figure out how to interpret %s as a date or time Ignoring unrecognised debug flag %s In %s the %s must appear by itself, but you specified %s Invalid argument %s for option --max-database-age Invalid argument %s to -used Invalid argument `%s%s' to -size Invalid escape sequence %s in input delimiter specification. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lo. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lx. Invalid escape sequence %s in input delimiter specification; trailing characters %s not recognised. Invalid input delimiter specification %s: the delimiter must be either a single character or an escape sequence starting with \. Invalid optimisation level %s James Youngman Kevin Dalley Locate database size: %s byte
 Locate database size: %s bytes
 Mandatory and optional arguments to long options are also
mandatory or optional for the corresponding short option.
 Matching Filenames: %s
 Old-format locate database %s is too short to be valid Only one instance of {} is supported with -exec%s ... + Optimisation level %lu is too high.  If you want to find files very quickly, consider using GNU locate. Please specify a decimal number immediately after -O Run COMMAND with arguments INITIAL-ARGS and more arguments read from input.

 Security level %s has unexpected suffix %s. Security level %s is outside the convertible range. Some filenames may have been filtered out, so we cannot compute the compression ratio.
 Symbolic link %s is part of a loop in the directory hierarchy; we have already visited the directory to which it points. The %s test needs an argument The -O option must be immediately followed by a decimal integer The -delete action automatically turns on -depth, but -prune does nothing when -depth is in effect.  If you want to carry on anyway, just explicitly use the -depth option. The -show-control-chars option takes a single argument which must be 'literal' or 'safe' The argument for option --max-database-age must not be empty The argument to -user should not be empty The atexit library function failed The current directory is included in the PATH environment variable, which is insecure in combination with the %s action of find.  Please remove the current directory from your $PATH (that is, remove ".", doubled colons, or leading or trailing colons) The database has big-endian machine-word encoding.
 The database has little-endian machine-word encoding.
 The database machine-word encoding order is not obvious.
 The environment is too large for exec(). The environment variable FIND_BLOCK_SIZE is not supported, the only thing that affects the block size is the POSIXLY_CORRECT environment variable The relative path %s is included in the PATH environment variable, which is insecure in combination with the %s action of find.  Please remove that entry from $PATH This system does not provide a way to find the birth time of a file. Unexpected suffix %s on %s Unknown regular expression type %s; valid types are %s. Usage: %s [-0 | --null] [--version] [--help]
 Usage: %s [-d path | --database=path] [-e | -E | --[non-]existing]
      [-i | --ignore-case] [-w | --wholename] [-b | --basename] 
      [--limit=N | -l N] [-S | --statistics] [-0 | --null] [-c | --count]
      [-P | -H | --nofollow] [-L | --follow] [-m | --mmap] [-s | --stdio]
      [-A | --all] [-p | --print] [-r | --regex] [--regextype=TYPE]
      [--max-database-age D] [--version] [--help]
      pattern...
 Usage: %s [OPTION]... COMMAND [INITIAL-ARGS]...
 WARNING: Lost track of %lu child processes WARNING: a NUL character occurred in the input.  It cannot be passed through in the argument list.  Did you mean to use the --null option? WARNING: cannot determine birth time of file %s WARNING: file %s appears to have mode 0000 WARNING: locate database %s was built with a different byte order Warning: %s will be run at least once.  If you do not want that to happen, then press the interrupt keystroke.
 You may not use {} within the utility name for -execdir and -okdir, because this is a potential security problem. You need to specify a security level as a decimal integer. You specified the -E option, but that option cannot be used with slocate-format databases with a non-zero security level.  No results will be generated for this database.
 argument line too long argument list too long argument to -group is empty, but should be a group name arithmetic overflow when trying to calculate the end of today arithmetic overflow while converting %s days to a number of seconds can't call exec() due to argument size restrictions cannot delete %s cannot fit single argument within argument list size limit cannot fork cannot search %s command too long could not create pipe before fork days double environment is too large for exec errno-buffer safe_read failed in xargs_do_exec (this is probably a bug, please report it) error reading a word from %s error waiting for %s error waiting for child process error: %s at end of format string error: the format directive `%%%c' is reserved for future use expected an expression after '%s' expected an expression between '%s' and ')' failed to drop group privileges failed to drop setgid privileges failed to drop setuid privileges failed to open /dev/tty for reading failed to restore working directory after searching %s failed to set environment variable %s failed to unset environment variable %s getfilecon failed: %s invalid -size type `%c' invalid argument `%s' to `%s' invalid expression invalid expression; I was expecting to find a ')' somewhere but did not see one. invalid expression; empty parentheses are not allowed. invalid expression; you have too many ')' invalid expression; you have used a binary operator '%s' with nothing before it. invalid mode %s invalid null argument to -size invalid predicate -context: SELinux is not enabled. invalid predicate `%s' locate database %s contains a filename longer than locate can handle locate database %s is corrupt or invalid locate database %s looks like an slocate database but it seems to have security level %c, which GNU findutils does not currently support missing argument to `%s' oops -- invalid default insertion of and! oops -- invalid expression type (%d)! oops -- invalid expression type! option --%s may not be set to a value which includes `=' sanity check of the fnmatch() library function failed. single slocate security level %ld is unsupported. standard error standard output time system call failed unexpected EOF in %s unexpected extra predicate unexpected extra predicate '%s' unknown unknown predicate `%s' unmatched %s quote; by default quotes are special to xargs unless you use the -0 option warning: -%s %s will not match anything because it ends with /. warning: escape `\' followed by nothing at all warning: format directive `%%%c' should be followed by another character warning: the -E option has no effect if -0 or -d is used.
 warning: the -d option is deprecated; please use -depth instead, because the latter is a POSIX-compliant feature. warning: the locate database can only be read from stdin once. warning: there is no entry in the predicate evaluation cost table for predicate %s; please report this as a bug warning: unrecognized escape `\%c' warning: unrecognized format directive `%%%c' warning: value %ld for -s option is too large, using %ld instead warning: you have specified a mode pattern %s (which is equivalent to /000). The meaning of -perm /000 has now been changed to be consistent with -perm -000; that is, while it used to match no files, it now matches all files. write error you have too many ')' Project-Id-Version: findutils 4.5.15
Report-Msgid-Bugs-To: bug-findutils@gnu.org
PO-Revision-Date: 2015-12-19 15:30+0100
Last-Translator: Petr Pisar <petr.pisar@atlas.cz>
Language-Team: Czech <translation-team-cs@lists.sourceforge.net>
Language: cs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Bugs: Report translation errors to the Language-Team address.
Plural-Forms: nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;
 
Vykonávání xargs bude nyní pokračovat. Bude se pokoušet číst svůj vstup a spouštět příkazy. Pokud to není to, co chcete, aby se dělo, prosím, stiskněte klávesy konce souboru.
       --help                   zobrazí tuto nápovědu a skončí
       --process-slot-var=PROMĚNNÁ
                               nastaví PROMĚNNOU prostředí v procesech
                               potomků
       --show-limits            zobrazí omezení na délku spouštěného příkazu
   -0, --null                   položky jsou odděleny nulovým bajtem, nikoliv
                               bílým znakem. Vypne zpracování uvozovek,
                               zpětných lomítek a konce souboru
   -E KONEC                     nastaví značkou logického konce souboru.
                               Vyskytne-li se KONEC jako řádek ve vstupu,
                               zbytek vstupu bude ignorován. (Tento přepínač
                               je potlačen přepínačem -0 nebo -d.)
   -I N                         stejné jako --replace=N
   -L, --max-lines=MAXIMUM      použije nejvýše MAXIMUM neprázdných vstupních
                               řádků na každé spuštění příkazu
   -P, --max-procs=MAXIMUM      spustí najednou nejvýše MAXIMUM procesů
   -a, --arg-file=SOUBOR        načte argumenty ze SOUBORU, ne ze
                               standardního vstupu
   -d, --delimiter=ZNAK         položky ve vstupním proudu jsou odděleny ZNAKEM,
                               nikoliv býlím místem. Vypne zpracování uvozovek,
                               zpětných lomítek a konce souboru.
   -e, --eof[=KONEC]            stejné jako -E KONEC, je-li KONEC zadán.
                               Jinak nebude rozpoznáván žádný řetězec značící
                               konec souboru.
   -l[MAXIMUM]                  podobné jako -L, ale není-li MAXIMUM zadáno,
                               použije se nejvýše jeden neprázdný vstupní řádek
   -n, --max-args=MAXIMUM       použije nejvýše MAXIMUM argumentů na
                               každé spuštění příkazu
   -p, --interactive            před spuštěním příkazů se dotáže
   -r, --no-run-if-empty        neexistují-li argumenty, PŘÍKAZ nebude
                               spuštěn. Není-li tento přepínač zadán, PŘÍKAZ
                               bude spuštěn alespoň jednou.
   -s, --max-chars=MAXIMUM      omezí délku spouštěného příkazu na MAXIMUM znaků
   -t, --verbose                vypíše příkazy před jejich spuštěním
   -x, --exit                   skončí, je-li délka (vizte -s) překročena
 %s je slocate databáze s nepodporovanou úrovní zabezpečení %d, vynechávám ji. %s je slocate databáze. Zapínám přepínač „-e“. %s není jméno známého uživatele %s není jméno existující skupiny %s není jméno existující skupiny, a ani nevypadá jako číselný identifikátor skupiny, protože obsahuje neočekávanou příponu %s %s ukončen signálem %d %s: ukončen s kódem 255, končím %s: pozastaven signálem %d %s: ukončen signálem %d < %s … %s > ?  Všechny názvy souborů: %s
 Standardní vstup nelze uzavřít Čas vytvoření souboru %s nelze získat. Vstupní soubor %s nelze otevřít. Seznam připojených souborových systémů nemohl být načten Nelze nastavit obsluhu signálu SIGUSR1 Nelze nastavit obsluhu signálu SIGUSR2 Kompresní poměr %4.2f %% (vyšší je lepší)
 Kompresní poměr není definován
 Databáze %s je ve formátu %s.
 Databáze byla naposledy upravena v %s,%09ld Prázdný argument přepínače -D. Proměnná prostředí %s není nastavena na platné desítkové číslo Eric B. Decker U %s očekáván kladný desítkový celočíselný argument, avšak obdrženo %s Očekáváno celé číslo: %s Zbavení se všech práv selhalo Inicializace hash tabulky sdílených souborů selhala Čtení ze standardního vstupu selhalo Uložení pracovního adresáře za účelem spuštění příkazu nad %s selhal Zápis na výstup selhal (ve fázi %d) Zápis výzvy pro -ok selhal Zápis na standardní výstup selhal Zápis na standardní chybový výstup selhal Povolené vlastnosti:  Deskriptor souboru %d unikne. Prosím, ohlaste to jako chybu a nezapomeňte uvést podrobný popis nejjednoduššího způsobu, jak tento problém vyvolat. Názvy souborů mají celkovou délku %s bajtů.
Z těchto názvů,

	%s obsahuje bílé místo, 
	%s obsahuje znak nového řádku, 
	a %s obsahuje znaky s nastaveným horním bitem.
 Odhalena smyčka souborových systémů: %s je součástí stejné smyčky souborových systémů jako %s. Nevím, jak mám vyčíst datum nebo čas z %s Ignoruji nerozpoznaný ladicí příznak %s V %s se %s musí objevit samotné, ale vy jste zadali %s Neplatný argument %s přepínače -max-database-age Neplatný argument %s u -used Neplatný argument „%s%s“ u -size Neplatná escape posloupnost %s v zadání oddělovače vstupu. Neplatná escape posloupnost %s v zadání oddělovače vstupu, hodnoty znaků nesmí přesáhnout %lo. Neplatná escape posloupnost %s v zadání oddělovače vstupu, hodnoty znaků nesmí přesáhnout %lx. Neplatná escape posloupnost %s v zadání oddělovače vstupu, závěrečné znaky %s nebyly rozeznány. Neplatné určení oddělovače vstupu %s: oddělovač musí být buď jediný znak, nebo escape posloupnost začínající \. Neplatná úroveň optimalizace %s James Youngman Kevin Dalley Velikost locate databáze: %s bajt
 Velikost locate databáze: %s bajty
 Velikost locate databáze: %s bajtů
 Povinné a volitelné argumenty dlouhých přepínačů jsou také povinné nebo
volitelné u odpovídajících krátkých přepínačů.
 Odpovídající názvy souborů: %s
 Locate databáze %s ve starém formátu je příliš krátká na to, aby byla platná. U -exec%s … + je podporována jen jedna instance {}. Úroveň optimalizace %lu je příliš vysoká. Potřebujte-li hledat soubory velmi rychle, zvažte použití GNU locate. Prosím, zadejte desítkové číslo okamžitě po -O Spustí PŘÍKAZ s ÚVODNÍMI_ARGUMENTY následovanými dalšími argumenty přečtenými
ze standardního vstupu.
 úroveň zabezpečení %s má neočekávanou příponu %s. Úroveň zabezpečení %s je mimo převoditelný rozsah. Některé názvy souborů mohly být vynechány, takže nemůžeme spočítat kompresní poměr.
 Symbolický odkaz %s je součástí smyčky v hierarchii adresářů. Adresář, na který ukazuje, jsme již navštívili. Test %s vyžaduje argument Přepínač -D musí být bezprostředně následován desítkovým celým číslem. Akce -delete automaticky zapíná -depth, ale -prune nic nedělá, je-li -depth zapnut. Chcete-li přesto pokračovat, prostě explicitně použijte přepínač -depth. Přepínač -show-control-chars bere jediný argument, který musí být „literal“ (doslovný) nebo „safe“ (bezpečný). Argument přepínače --max-database-age nesmí být prázdný Argument přepínače -user by neměl být prázdný Knihovní funkce atexit() selhala Současný adresář je obsažen v proměnné prostředí PATH, což je nebezpečné ve spojení s akcí findu %s. Prosím, odstraňte současný adresář z vaší $PATH (to jest, odeberte „.“, zdvojené dvojtečky nebo úvodní nebo závěrečné dvojtečky). Databáze má strojová slova kódována ve velké endianitě.
 Databáze má strojová slova kódována v malé endianitě.
 Kódování strojových slov databáze není zřejmé.
 Prostředí je příliš veliké na exec(). Proměnná prostředí FIND_BLOCK_SIZE není podporována. Jediná věc, která ovlivňuje velikost bloku je proměnná prostředí POSIXLY_CORRECT. Relativní cesta %s je obsažena v proměnné prostředí PATH, což je nebezpečné ve spojení s akcí findu %s. Prosím, odstraňte tuto položku z $PATH. Tento systém neposkytuje způsob, jak zjistit čas vytvoření souboru. Neočekávaná přípona %s u %s Neznámý typ regulárního výrazu %s, platné typy jsou %s. Užití: %s [-0 | --null] [--version] [--help]
 Užití: %s [-d CESTA | --database=CESTA] [-e | -E | --[non-]existing]
      [-i | --ignore-case] [-w | --wholename] [-b | --basename] 
      [--limit=N | -l N] [-S | --statistics] [-0 | --null] [-c | --count]
      [-P | -H | --nofollow] [-L | --follow] [-m | --mmap ] [ -s | --stdio]
      [-A | --all] [-p | --print] [-r | --regex] [--regextype=TYP]
      [--max-database-age D] [--version] [--help]
      VZOR…
 Použití: %s [PŘEPÍNAČ]… PŘÍKAZ [ÚVODNÍ_ARGUMENTY]…
 POZOR: Ztracena stopa %lu potomků POZOR: Na vstupu se objevil znak NULL. Není možné jej předat do seznamu argumentů. Nezamýšleli jste použít přepínač --null? POZOR: čas vytvoření souboru %s není možné určit POZOR: zdá se, že soubor %s má mód 0000 POZOR: locate databáze %s byla sestaveno v jiném pořadí bajtů Varování: %s bude spuštěn alespoň jednou. Pokud nechcete, aby se stalo, pak stiskněte klávesy přerušení.
 Neměli byste používat {} uvnitř názvu nástroje u -execdir a -okdir, protože to představuje možný bezpečnostní problém. Úroveň zabezpečení je třeba zadat jako desítkové celé číslo. Zadali jste přepínač -E, ale tento přepínač nemůže být použit s databází v slocate formátu a nenulovou úrovní zabezpečení. Pro tuto databázi nebudou vytvořeny žádné výsledky.
 řádka s argumenty je příliš dlouhá seznam argumentů je příliš dlouhý argument u -group je prázdný, měl by představovat jméno skupiny aritmetické přetečení při pokusu vypočítat konec dnešního dne aritmetické přetečení při pokusu převést %s dnů na počet sekund kvůli omezením velikosti argumentů není možné zavolat exec() %s není možné smazat s jediným argumentem se nelze vejít do limitu velikosti seznamu argumentů nelze vykonat fork() %s nelze prohledat příkaz je příliš dlouhý před fork() nebylo možné vyrobit rouru dnů dvojitá prostředí je na exec() příliš velké volání safe_read nad errno-buffer selhalo v xargs_do_exec (pravděpodobně se jedná o chybu, prosím, ohlaste to) chyba při čtení slova z %s chyba při čekání na %s chyba při čekání na proces potomka chyba: na konci formátovací řetězce je %s chyba: formátovací direktiva „%%%c“ je vyhrazena pro budoucí použití po „%s“ očekáván výraz mezi „%s“ a „)“ očekáván výraz zbavení se práv skupiny selhalo zbavení se setgid práv selhalo zbavení se setuid práv selhalo /dev/tty nebylo možné otevřít pro čtení návrat do prvotního pracovního adresáře po prohledání %s selhal nastavení proměnné prostředí %s selhalo nepodařilo se zrušit proměnnou prostředí %s getfilecon selhala: %s neplatný druh „%c“ u -size neplatný argument „%s“ u „%s“ neplatný výraz neplatný výraz: Čekal jsem, že někde naleznu „)“, ale nenašel jsem ani jednu. neplatný výraz: prázdné závorky nejsou povoleny. neplatný výraz: máte moc „)“ neplatný výraz: použili jste binární operátor „%s“, aniž by mu cokoliv předcházelo. neplatný mód %s neplatný prázdný argument u -size neplatný predikát -context: SELinux není zapnut. neplatný predikát „%s“ locate databáze %s obsahuje delší název souboru, než s jakým může locate zacházet locate databáze %s je poškozena nebo není platná locate databáze %s vypadá jako slocate databáze, akorát má úroveň zabezpečení %c, což GNU findutils zatím nepodporuje. u „%s“ chybí argument ajaj – neplatné implicitní vložení operátoru and! ajaj – neplatný typ výrazu (%d)! ajaj – neplatný typ výrazu! přepínači --%s nesmí být zadána hodnota obsahující „=“ kontrola nezávadnosti knihovní funkce fnmatch() selhala. jednoduchá Úroveň zabezpečení slocate %ld není podporována. standardní chybový výstup standardní výstup služba systému time selhala neočekávaný EOF v %s neočekávaný nadbytečný predikát neočekávaný nadbytečný predikát „%s“ neznámý neznámý predikát „%s“ neodpovídající %s uvozovka; implicitně jsou pro xargs uvozovky zvláštními znaky, dokud nepoužijete přepínač -0 pozor: -%s %s nic nenajde, protože končí na /. pozor: řídicí znak „\“ není vůbec ničím následován varování: formátovací direktiva „%%%c“ by měla být následována dalším znakem pozor: přepínač -E je bez účinku, je-li použit -0 nebo -d.
 varování: přepínač -d se nedoporučuje, prosím, místo něj použijte -depth, protože tato druhá forma je podle POSIXU. varování: locate databázi lze ze standardního vstupu číst jen jednou. varování: predikát %s nemá žádný záznam v tabulce obtížnosti vyhodnocování predikátů. Prosím, nahlaste to jako chybu. pozor: nerozpoznaný řídicí znak „\%c“ varování: nerozpoznaná formátovací direktiva „%%%c“ pozor: hodnota %ld přepínače -s je příliš velká, místo toho se použije %ld varování: zadali jste vzor módu %s (což je ekvivalentní /000). Význam -perm /000 byl nyní pozměněn tak, aby byl jednotný s -perm -000. To jest, dříve se neshodoval s žádnými soubory, nyní se shoduje se všemi. chyba zápisu máte moc „)“ PRIuMAX Your environment variables take up % bytes
 POSIX upper limit on argument length (this system): %
 POSIX smallest allowable upper limit on argument length (all systems): %
 Maximum length of command we could actually use: %
 Size of command buffer we are actually using: %
 Maximum parallelism (--max-procs must be no greater): %
 Vaše proměnné prostředí zabírají %' bajtů
 Horní mez délky argumentů dle POSIXU (tento sytém): %'
 Nejmenší možná horní mez délky argumentů dle POSIXU (všechny systémy): %'
 Maximální délka příkazu, který tedy můžeme použít: %'
 Velikost bufferu příkazu, který tedy používáme: %'
 Maximální paralelismus (--max-procs nesmí být větší): %'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          0                   ,      4     5  :     O     B   m            3   e  }     I     L   a               -  O     >        [  I   0  D   z  E     H     7   N  "     '     |        N  $   i                           #        '  $   A  !   f  !     -          !     &         A  <   b       >               +   %     Q  @   k  $          "             -     @       I      9      #   !  8   4!  1   m!     !      !  <   !  b   "  b   }"  c   "     D#     #     #     #  >   #  t   >$     $  6   $  7   %  g   :%  4   %  M   %  +   %&  3   Q&  W   &  x   &     V'  ?   t'     '  X   `(  <   (  )   (  "    )     C)  3   >*  6   r*  9   *  (   *     +     +  D   C,     ,  7   ,  -   ,    	-  0   .  *   .     /  /   /  *   /  A   /  o   -0  q   0  :   1     J1     1     
2  7   $2  =   \2  C   2  3   2     3  :   #3     ^3     j3     {3  !   3     3     3  !   3  Y   3     64     S4     h4  !   4  =   4  !   4  +   
5     65      V5      w5  #   5  6   5  %   5  '   6     A6     W6     o6     6  P   6  6   6  )   (7  P   R7     7     7  3   7     8  D   8  (   b8     8     9  )   -9  %   W9      }9  8   9  6   9     :  *   :     @:     O:     _:     w:     :     :     :     :  W   :  ?   >;  .   ~;  H   ;  :   ;  q   1<  >   <  o   <  "   R=  -   u=  @   =     =     >     >    >     @  @   HA  H   A  L   A     B      C  5   C     D  I   D  N   D    =E     VF     F  R   G  C   
H     NH  N   :I  A   I  K   I  [   J  4   sJ  %   J  ,   J  ~   J     zK  %   K     K     K     K      L     L  0   3L     dL  .   L  )   L  )   L  0   M  %   7M     ]M  )   |M     M  1   M     M  >   N     FN  #   _N  .   N      N  =   N  &   O      8O  %   YO  "   O     O     O     XP  D   Q  K   YQ  %   Q  (   Q  5   Q     *R  "   IR  @   lR  e   R  e   S  d   yS     S     hT     T     T  G   T  ~   T     iU  F   U  9   U  n   V  -   qV  ]   V  -   V  <   +W  W   hW  v   W     7X  2   VX     X  _   ,Y  ?   Y  )   Y  '   Y     Z  3   [  4   L[  2   [  !   [     [     Y\  K   ]     T]  8   n]  ,   ]    ]  :   l_  6   _     _  =   c`  .   `  A   `     a  j   a  7   a     6b     b     c  ;   +c  G   gc  E   c  I   c     ?d  F   Rd     d     d     d  /   d     e     e  !   e  w   >e     e  &   e  /   e  !   -f  >   Of     f  '   f  #   f  $   f  $   g  &   Dg  K   kg  #   g  $   g      h     h     3h     Sh  U   ch  0   h     h  I   	i     Si     gi  7   i     i  S   i  -   (j     Vj     j  /   k     @k     `k  @   {k  @   k     k  6   l     ;l     Hl     Xl     xl     l     l     l     l  r   l  =   Gm  -   m  B   m  A   m  ^   8n  C   n  {   n  "   Wo  -   zo  I   o     o  
   p     p           O             $                                      w             >   u   d                    -            Y       i         j            +   y                     G   
                 e   ;                              =          Z                h         	         E   *                 I   x      W   k             "   
                          r   2      S   [   @      9   D              .              8      '   )      `                                           B      g       C   m         q          0      6       X      b       #   z   s   %   p       N   F   H       _   ?      ]          c   5              l   7   A                  1             M   V   L   P       |                        \   }   R      K   :   <       o           3   n   {                                   /                                      T   ^          U   Q   ,      f   &   J                  v   !      4                      t   ~       (       a      q  D  X  l                     q  $          Bq  5          yq  H          q  2          q  /          (r  7          ar            r  B          r  N          s  8          Rs  6          s  =           
Execution of xargs will continue now, and it will try to read its input and run commands; if this is not what you wanted to happen, please type the end-of-file keystroke.
       --help                   display this help and exit
       --process-slot-var=VAR   set environment variable VAR in child processes
       --show-limits            show limits on command-line length
   -0, --null                   items are separated by a null, not whitespace;
                                 disables quote and backslash processing and
                                 logical EOF processing
   -E END                       set logical EOF string; if END occurs as a line
                                 of input, the rest of the input is ignored
                                 (ignored if -0 or -d was specified)
   -I R                         same as --replace=R
   -L, --max-lines=MAX-LINES    use at most MAX-LINES non-blank input lines per
                                 command line
   -P, --max-procs=MAX-PROCS    run at most MAX-PROCS processes at a time
   -a, --arg-file=FILE          read arguments from FILE, not standard input
   -d, --delimiter=CHARACTER    items in input stream are separated by CHARACTER,
                                 not by whitespace; disables quote and backslash
                                 processing and logical EOF processing
   -e, --eof[=END]              equivalent to -E END if END is specified;
                                 otherwise, there is no end-of-file string
   -l[MAX-LINES]                similar to -L but defaults to at most one non-
                                 blank input line if MAX-LINES is not specified
   -n, --max-args=MAX-ARGS      use at most MAX-ARGS arguments per command line
   -p, --interactive            prompt before running commands
   -r, --no-run-if-empty        if there are no arguments, then do not run COMMAND;
                                 if this option is not given, COMMAND will be
                                 run at least once
   -s, --max-chars=MAX-CHARS    limit length of command line to MAX-CHARS
   -t, --verbose                print commands before executing them
   -x, --exit                   exit if the size (see -s) is exceeded
 %s is an slocate database of unsupported security level %d; skipping it. %s is an slocate database.  Turning on the '-e' option. %s is not the name of a known user %s is not the name of an existing group %s is not the name of an existing group and it does not look like a numeric group ID because it has the unexpected suffix %s %s terminated by signal %d %s: exited with status 255; aborting %s: stopped by signal %d %s: terminated by signal %d < %s ... %s > ?  All Filenames: %s
 Cannot close standard input Cannot obtain birth time of file %s Cannot open input file %s Cannot read mounted file system list Cannot set SIGUSR1 signal handler Cannot set SIGUSR2 signal handler Compression ratio %4.2f%% (higher is better)
 Compression ratio is undefined
 Database %s is in the %s format.
 Database was last modified at %s.%09ld Empty argument to the -D option. Environment variable %s is not set to a valid decimal number Eric B. Decker Expected a positive decimal integer argument to %s, but got %s Expected an integer: %s Failed to fully drop privileges Failed to initialize shared-file hash table Failed to read from stdin Failed to save working directory in order to run a command on %s Failed to write output (at stage %d) Failed to write prompt for -ok Failed to write to standard output Failed to write to stderr Features enabled:  File descriptor %d will leak; please report this as a bug, remembering to include a detailed description of the simplest way to reproduce this problem. File names have a cumulative length of %s bytes.
Of those file names,

	%s contain whitespace, 
	%s contain newline characters, 
	and %s contain characters with the high bit set.
 File system loop detected; %s is part of the same file system loop as %s. I cannot figure out how to interpret %s as a date or time Ignoring unrecognised debug flag %s In %s the %s must appear by itself, but you specified %s Invalid argument %s for option --max-database-age Invalid argument %s to -used Invalid argument `%s%s' to -size Invalid escape sequence %s in input delimiter specification. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lo. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lx. Invalid escape sequence %s in input delimiter specification; trailing characters %s not recognised. Invalid input delimiter specification %s: the delimiter must be either a single character or an escape sequence starting with \. Invalid optimisation level %s James Youngman Kevin Dalley Locate database size: %s byte
 Locate database size: %s bytes
 Mandatory and optional arguments to long options are also
mandatory or optional for the corresponding short option.
 Matching Filenames: %s
 Old-format locate database %s is too short to be valid Only one instance of {} is supported with -exec%s ... + Optimisation level %lu is too high.  If you want to find files very quickly, consider using GNU locate. Please specify a decimal number immediately after -O Run COMMAND with arguments INITIAL-ARGS and more arguments read from input.

 Security level %s has unexpected suffix %s. Security level %s is outside the convertible range. Some filenames may have been filtered out, so we cannot compute the compression ratio.
 Symbolic link %s is part of a loop in the directory hierarchy; we have already visited the directory to which it points. The %s test needs an argument The -O option must be immediately followed by a decimal integer The -delete action automatically turns on -depth, but -prune does nothing when -depth is in effect.  If you want to carry on anyway, just explicitly use the -depth option. The -show-control-chars option takes a single argument which must be 'literal' or 'safe' The argument for option --max-database-age must not be empty The argument to -user should not be empty The atexit library function failed The current directory is included in the PATH environment variable, which is insecure in combination with the %s action of find.  Please remove the current directory from your $PATH (that is, remove ".", doubled colons, or leading or trailing colons) The database has big-endian machine-word encoding.
 The database has little-endian machine-word encoding.
 The database machine-word encoding order is not obvious.
 The environment is too large for exec(). The environment variable FIND_BLOCK_SIZE is not supported, the only thing that affects the block size is the POSIXLY_CORRECT environment variable The relative path %s is included in the PATH environment variable, which is insecure in combination with the %s action of find.  Please remove that entry from $PATH This system does not provide a way to find the birth time of a file. Unexpected suffix %s on %s Unknown regular expression type %s; valid types are %s. Usage: %s [-0 | --null] [--version] [--help]
 Usage: %s [-d path | --database=path] [-e | -E | --[non-]existing]
      [-i | --ignore-case] [-w | --wholename] [-b | --basename] 
      [--limit=N | -l N] [-S | --statistics] [-0 | --null] [-c | --count]
      [-P | -H | --nofollow] [-L | --follow] [-m | --mmap] [-s | --stdio]
      [-A | --all] [-p | --print] [-r | --regex] [--regextype=TYPE]
      [--max-database-age D] [--version] [--help]
      pattern...
 Usage: %s [OPTION]... COMMAND [INITIAL-ARGS]...
 WARNING: Lost track of %lu child processes WARNING: a NUL character occurred in the input.  It cannot be passed through in the argument list.  Did you mean to use the --null option? WARNING: cannot determine birth time of file %s WARNING: file %s appears to have mode 0000 WARNING: locate database %s was built with a different byte order Warning: %s will be run at least once.  If you do not want that to happen, then press the interrupt keystroke.
 You may not use {} within the utility name for -execdir and -okdir, because this is a potential security problem. You need to specify a security level as a decimal integer. You specified the -E option, but that option cannot be used with slocate-format databases with a non-zero security level.  No results will be generated for this database.
 argument line too long argument list too long argument to -group is empty, but should be a group name arithmetic overflow when trying to calculate the end of today arithmetic overflow while converting %s days to a number of seconds can't call exec() due to argument size restrictions cannot delete %s cannot fit single argument within argument list size limit cannot fork cannot search %s command too long could not create pipe before fork days double environment is too large for exec errno-buffer safe_read failed in xargs_do_exec (this is probably a bug, please report it) error reading a word from %s error waiting for %s error waiting for child process error: %s at end of format string error: the format directive `%%%c' is reserved for future use expected an expression after '%s' expected an expression between '%s' and ')' failed to drop group privileges failed to drop setgid privileges failed to drop setuid privileges failed to open /dev/tty for reading failed to restore working directory after searching %s failed to set environment variable %s failed to unset environment variable %s getfilecon failed: %s invalid -size type `%c' invalid argument `%s' to `%s' invalid expression invalid expression; I was expecting to find a ')' somewhere but did not see one. invalid expression; empty parentheses are not allowed. invalid expression; you have too many ')' invalid expression; you have used a binary operator '%s' with nothing before it. invalid mode %s invalid null argument to -size invalid predicate -context: SELinux is not enabled. invalid predicate `%s' locate database %s contains a filename longer than locate can handle locate database %s is corrupt or invalid locate database %s looks like an slocate database but it seems to have security level %c, which GNU findutils does not currently support missing argument to `%s' oops -- invalid default insertion of and! oops -- invalid expression type (%d)! oops -- invalid expression type! option --%s may not be set to a value which includes `=' sanity check of the fnmatch() library function failed. single slocate security level %ld is unsupported. standard error standard output time system call failed unexpected EOF in %s unexpected extra predicate unexpected extra predicate '%s' unknown unknown predicate `%s' unmatched %s quote; by default quotes are special to xargs unless you use the -0 option warning: -%s %s will not match anything because it ends with /. warning: escape `\' followed by nothing at all warning: format directive `%%%c' should be followed by another character warning: the -E option has no effect if -0 or -d is used.
 warning: the -d option is deprecated; please use -depth instead, because the latter is a POSIX-compliant feature. warning: the locate database can only be read from stdin once. warning: there is no entry in the predicate evaluation cost table for predicate %s; please report this as a bug warning: unrecognized escape `\%c' warning: unrecognized format directive `%%%c' warning: value %ld for -s option is too large, using %ld instead warning: you have specified a mode pattern %s (which is equivalent to /000). The meaning of -perm /000 has now been changed to be consistent with -perm -000; that is, while it used to match no files, it now matches all files. write error you have too many ')' Project-Id-Version: findutils 4.5.15
Report-Msgid-Bugs-To: bug-findutils@gnu.org
PO-Revision-Date: 2016-01-23 22:51+0200
Last-Translator: Joe Hansen <joedalton2@yahoo.dk>
Language-Team: Danish <dansk@dansk-gruppen.dk>
Language: da
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Bugs: Report translation errors to the Language-Team address.
Plural-Forms: nplurals=2; plural=(n != 1)
 
Kørslen af xargs vil nu fortsætte, og denne vil forsøge at læse dens inddata og køre kommandoer; hvis dette ikke er hvad du ønsker, så skriv et filsluttegn (end-of-file).
       --help                   vis denne hjælpetekst og afslut
       --process-slot-var=VAR   sæt miljøvariabel VAR i underprocesser
       --show-limits            vis begrænsninger for kommandolinjelængden
   -0, --null                   elementer adskilles af null, ikke blanktegn;
                                 deaktiverer behandling af citat- og omvendt
                                 skråstreg samt logisk EOF-behandling
   -E SLUT                      sæt logisk EOF-streng; hvis SLUT opstår som en
                                 inddatalinje ignoreres resten af inddataene
                                 (ignoreres hvis -0 eller -d blev angivet)
   -I R                         samme som --replace=R
   -L, --max-lines=MAKS-LINJER  brug højst MAKS-LINJER ikke-blanke inddatalinjer per
                                 kommandolinje
   -P, --max-procs=MAKS-PROC    kør højst MAKS-PROC processer ad gangen
   -a, --arg-file=FIL           læser parametre fra FIL, ikke standardinddata
   -d, --delimiter=TEGN         elementer i inddatastrømme adskilles af TEGN,
                                 frem for blanktegn; deaktiverer behandling af
                                 citat- og omvendt skråstreg samt logisk EOF-
                                 behandling
   -e, --eof[=SLUT]             svarer til -E SLUT hvis SLUT er specificeret;
                                 ellers, er der ingen slut på fil-streng
   -l[MAKS-LINJER]              svarer til -L men bruger standarden på mindst en
                                 ikke tom inddatalinje hvis MAKS-LINJER ikke er
                                 givet
   -n, --max-args=MAKS-PARM     brug højest MAKS-PARM-parametre per kommandolinje
   -p, --interactive            spørg før udførsel af kommandoer
   -r, --no-run-if-empty        hvis der ikke er nogen parametre, så udfør ikke KOMMANDO;
                                 hvis dette tilvalg ikke er angivet, vil KOMMANDO blive
                                 udført mindst en gang
   -s, --max-chars=MAKS-TEGN    begræns kommandolinjens længde til MAKS-TEGN
   -t, --verbose                udskriv kommandoer før de køres
   -x, --exit                   afslut hvis størrelsen (se -s) overskrides
 %s er en slocate-database med sikkerhedsniveauet %d, som ikke understøttes; springer over. %s er en slocate-database.  Slår '-e'-tilvaget til. %s er ikke navnet på en kendt bruger %s er ikke navnet på en eksisterende gruppe %s er ikke navnet på en eksisterende gruppe, og ligner heller ikke en numerisk gruppe-id på grund af det uventede suffiks %s %s afsluttet af signal %d %s: stoppede med status 255; afbryder %s: standset af signal %d %s: afsluttet af signal %d < %s ... %s > ?  Alle filnavne: %s
 Kan ikke lukke standard-inddata Kan ikke hente oprettelsestidspunkt for filen %s Kan ikke åbne inddatafilen %s Kan ikke læse listen af monterede filsystemer Kan ikke angive SIGUSR1-signalhåndtering Kan ikke angive SIGUSR2-signalhåndtering Komprimeringsforhold %4.2f%% (større er bedre)
 Komprimeringsforholdet er udefineret
 Database %s er i formatet %s.
 Databasen blev sidst ændret den %s.%09ld Tom parameter til -D-tilvalget. Miljøvariablen %s er ikke sat til et gyldigt tal Eric B. Decker Forventede et positivt heltal som parameter til %s, men fik %s Forventede et heltal: %s Kunne ikke fuldt afgive privilegier Kunne ikke klargøre hashtabel for delte filer Kunne ikke læse fra standardind Kunne ikke gemme arbejdsmappe for at køre en kommando på %s Kunne ikke skrive uddata (på trin %d) Kunne ikke skrive prompt for -ok Kunne ikke skrive til standard-uddata Kunne ikke skrive til standardfejl Faciliteter aktiveret:  Fildeskriptor %d vil lække; rapporter venligst som en fejl, og husk at inkludere en detaljeret beskrivelse af den simpleste måde at genskabe dette problem. Filnavnene har en kumulativ længde på %s byte.
For disse filnavne gælder:

	%s indeholder blanke tegn,
	%s indeholder linjeskiftstegn, 
	og %s indeholder tegn med den høje bit givet.
 Filsystemsløkke fundet; %s er del af samme filsystemsløkke som %s. Jeg kan ikke finde ud af hvordan %s skal fortolkes som dato eller tidspunkt Ignorerer ukendt fejlsøgningsflag %s I %s skal %s stå alene, men du angav %s Ugyldig parameter %s til tilvalget --max-database-age Ugyldig parameter %s til -used Ugyldig parameter `%s%s' til -size Ugyldig undvigesekvens %s i angivelse af skilletegn for inddata. Ugyldig undvigesekvens %s i angivelse af skilletegn for inddata; tegnværdier må ikke overstige %lo. Ugyldig undvigesekvens %s i angivelse af skilletegn for inddata; tegnværdier må ikke overstige %lx. Ugyldig undvigesekvens %s i angivelse af skilletegn for inddata; afsluttende tegn %s genkendes ikke. Ugyldig angivelse af skilletegn %s for inddata: skilletegnet skal være enten et enkelt tegn eller en undvigesekvens, der begynder med \. Ugyldigt optimeringsniveau %s James Youngman Kevin Dalley Locate-databasestørrelse: %s byte
 Locate-databasestørrelse: %s byte
 Obligatoriske og valgfrie parametre til lange tilvalg er også
obligatoriske eller valgfrie for de tilsvarende korte tilvalg.
 Matchende filnavne: %s
 Locate-databasen %s med gammelt format er for kort til at være gyldig Kun en forekomst af {} er understøttet med -exec%s ... + Optimeringsniveauet %lu er for højt.  Hvis du vil finde filer meget hurtigt, så overvej at bruge GNU locate. Angiv venligst et heltal umiddelbart efter -O Kør KOMMANDO med parametre OPRINDELIGE-PARAMETRE og flere parametre som læses
fra inddata

 Sikkerhedsniveauet %s har uventet suffiks %s. Sikkerhedsniveauet %s er uden for det meningsfulde interval. Visse filnavne kan være filtreret ud, så vi kan ikke beregne komprimeringsforholdet.
 Den symbolske lænke %s er del af en løkke i kataloghierarkiet; kataloget, den peger på, er allerede blevet besøgt. Testen %s kræver en parameter Tilvalget -O skal følges umiddelbart af et heltal Handlingen -delete slår automatisk -depth til, men -prune gør intet når -depth er givet.  Hvis du alligevel vil fortsætte, så giv tilvalget -depth eksplicit. Tilvalget -show-control-chars kræver en enkelt parameter som skal være 'literal' eller 'safe' Parameteren for tilvalget --max-database-age må ikke være tom Parameteren til -user bør ikke være tom Biblioteksfunktionen atexit mislykkedes Det aktuelle katalog er medtaget i miljøvariablen PATH hvilket er usikkert, når det kombineres med handlingen %s til find. Fjern venligst det aktuelle katalog fra din $PATH (dvs. fjern ".", dobbelte koloner eller begyndende og afsluttende koloner) Databasen bruger stor-endian kodning af maskinord.
 Databasen bruger lille-endian kodning af maskinord.
 Databasens kodning af maskinord er ikke åbenlys.
 Miljøet er for stort til exec(). Miljøvariablen FIND_BLOCK_SIZE er ikke understøttet, det eneste der påvirker blokstørrelsen er miljøvariablen POSIXLY_CORRECT Den relative sti %s er medtaget i miljøvariablen PATH, hvilket er usikkert når det kombineres med handlingen %s til find.  Fjern venligst det aktuelle katalog fra din $PATH Dette system giver ikke mulighed for at finde en fils oprettelsestidspunkt. Uventet suffiks %s på %s Ukendt type af regulært udtryk %s; gyldige typer er %s. Brug: %s [-0 | --null] [--version] [--help]
 Brug: %s [-d sti | --database=sti] [-e | -E | --[non-]existing]
     [-i | --ignore-case] [-w | --wholename] [-b | --basename] 
     [--limit=N | -l N] [-S | --statistics] [-0 | --null] [-c | --count]
     [-P | -H | --nofollow] [-L | --follow] [-m | --mmap] [-s | --stdio]
     [-A | --all] [-p | --print] [-r | --regex] [--regextype=TYPE]
     [--max-database-age D] [--version] [--help]
     mønster...
 Brug: %s [TILVALG]... KOMMANDO [OPRINDELIGE-PARAMETRE]...
 ADVARSEL: Kunne ikke holde rede på %lu underprocesser ADVARSEL: Der var et NUL-tegn i inddata.  Dette kan ikke videregives gennem parameterlisten.  Ønskede du at bruge tilvalget --null? ADVARSEL: Kan ikke bestemme oprettelsestidspunkt for filen %s ADVARSEL: Filen %s synes at have tilstand 0000 ADVARSEL: locate-databasen %s blev bygget med en anden byte-orden Advarsel: %s vil blive kørt mindst én gang.  Hvis du ikke ønsker at dette skal ske, så skriv afbrydelsestegnet (interrupt).
 Det kan ikke bruge {} i programnavnet for -execdir og -okdir fordi der er et potentielt sikkerhedsproblem. Du skal angive et sikkerhedsniveau i form af et heltal. Du gav tilvalget -E, men dette tilvalg kan ikke bruges sammen med slocate-formaterede databaser med sikkerhedsniveau forskelligt fra nul.  Ingen resultater vil blive genereret for denne database.
 parameterlinje for lang parameterliste for lang parameteren til -group er tom, men bør være et gruppenavn aritmetisk overløb ved forsøg på at udregne denne dags sluttidspunkt aritmetisk overløb ved konvertering af %s dage til et antal sekunder kan ikke kalde exec() på grund af begrænsninger på argumentstørrelser kan ikke slette %s kan ikke indpasse enkelt parameter inden for parameterlistestørrelsen kan ikke fraspalte en ny proces kan ikke søge i %s kommando for lang kunne ikke oprette dataledning (pipe) før fork dage dobbelt miljø for stort til at eksekvere errno-buffer safe_read mislykkedes i xargs_do_exec (dette er sandsynligvis en programfejl, så indrapportér den gerne) fejl ved læsning af ord fra %s fejl i forbindelse med at vente på %s fejl i forbindelse med at vente på afkomproces fejl: formatstreng slutter med %s fejl: formatdirektivet '%%%c' er reserveret til fremtidig brug forventede et udtryk efter '%s' forventede et udtryk mellem '%s' og ')' kunne ikke afgive gruppeprivilegier kunne ikke afgive setgid-privilegier kunne ikke afgive setuid-privilegier kunne ikke åbne /dev/tty til læsning kunne ikke vende tilbage til oprindeligt arbejdskatalog efter søgning i %s kunne ikke angive miljøvariabel %s kunne ikke fjerne miljøvariablen %s getfilecon mislykkedes: %s ugyldig -size type '%c' ugyldig parameter '%s' til '%s' ugyldigt udtryk ugyldigt udtryk; jeg forventede at finde en ')' et eller andet sted, men fandt ingen. ugyldigt udtryk; tomme parenteser tillades ikke. ugyldigt udtryk; for mange ')' ugyldigt udtryk; du har brugt den binære operator '%s' uden noget foran. ugyldig tilstand %s ugyldig tom parameter til -size ugyldigt prædikat -context: SELinix er ikke aktiveret. ugyldigt udsagn '%s' locate-databasen %s indeholder et filnavn, der er længere end locate kan håndtere locate-databasen %s er ødelagt eller ugyldig locate-databasen %s ser ud som en slocate-database, men synes at have sikkerhedsniveau %c, hvilket GNU findutils ikke understøtter på nuværende tidspunkt manglende parameter til '%s' ups - ugyldig automatisk indsættelse af 'and'! ups - ugyldig udtrykstype (%d)! ups - ugyldig udtrykstype! tilvalget --%s må ikke angives med en værdi som inkluderer '=' fornuftighedstjek af biblioteksfunktionen fnmatch() mislykkedes. enkelt Sikkerhedsniveauet %ld for slocate understøttes ikke. standardfejl standard-uddata systemkaldet time() mislykkedes uventet EOF i %s uventet ekstra udsagn uventet ekstra udsagn '%s' ukendt ukendt udsagn '%s' uafbalanceret citationstegn %s; som standard er citationstegn specielle for xargs medmindre du bruger tilvalget -0 advarsel: -%s %s vil ikke matche noget, da det slutter med /. advarsel: undvigetegn '\' efterfulgt af intet advarsel: formatdirektiv '%%%c' skal efterfølges af et andet tegn advarsel: Tilvalget -E har ingen effekt hvis -0 eller -d bruges.
 advarsel: tilvalget -d er forældet; benyt -depth i stedet som er i overenstemmelse med POSIX. advarsel: locate-databasen kan kun læses fra standard-ind en gang. advarsel: der er ingen post i evalueringsomkostningstabellen for udsagn for udsagn %s; rapporter venligst dette som en fejl advarsel: ukendt undvigetegn '\%c' advarsel: ukendt formatteringsdirektiv '%%%c' advarsel: værdien %ld for tilvalget -s er for stor - bruger %ld i stedet advarsel: du har angivet tilstandsmønsteret %s (som er ækvivalent med /000). Betydningen af -perm /000 er nu blevet ændret, så den er konsistent med -perm -000; dette vil sige, at mens det før ikke matchede nogen filer, matcher det nu alle filer. skrivefejl du har for mange ')' PRIuMAX Your environment variables take up % bytes
 POSIX upper limit on argument length (this system): %
 POSIX smallest allowable upper limit on argument length (all systems): %
 Maximum length of command we could actually use: %
 Size of command buffer we are actually using: %
 Maximum parallelism (--max-procs must be no greater): %
 Dine miljøvariable fylder % byte
 Øvre grænse på parameterlængde ifølge POSIX (dette system): %
 Mindste øvre grænse for parameterlængde tilladt af POSIX (alle systemer): %
 Maksimal længde af kommando der faktisk kunne bruges: %
 Størrelsen af kommandobufferen, som faktisk bruges: %
 Maksimal parallelitet (--max-procs må ikke være større): %
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              0                   ,      4     5  :     O     B   m            3   e  }     I     L   a               -  O     >        [  I   0  D   z  E     H     7   N  "     '     |        N  $   i                           #        '  $   A  !   f  !     -          !     &         A  <   b       >               +   %     Q  @   k  $          "             -     @       I      9      #   !  8   4!  1   m!     !      !  <   !  b   "  b   }"  c   "     D#     #     #     #  >   #  t   >$     $  6   $  7   %  g   :%  4   %  M   %  +   %&  3   Q&  W   &  x   &     V'  ?   t'     '  X   `(  <   (  )   (  "    )     C)  3   >*  6   r*  9   *  (   *     +     +  D   C,     ,  7   ,  -   ,    	-  0   .  *   .     /  /   /  *   /  A   /  o   -0  q   0  :   1     J1     1     
2  7   $2  =   \2  C   2  3   2     3  :   #3     ^3     j3     {3  !   3     3     3  !   3  Y   3     64     S4     h4  !   4  =   4  !   4  +   
5     65      V5      w5  #   5  6   5  %   5  '   6     A6     W6     o6     6  P   6  6   6  )   (7  P   R7     7     7  3   7     8  D   8  (   b8     8     9  )   -9  %   W9      }9  8   9  6   9     :  *   :     @:     O:     _:     w:     :     :     :     :  W   :  ?   >;  .   ~;  H   ;  :   ;  q   1<  >   <  o   <  "   R=  -   u=  @   =     =     >     >    >     @  @   A  Q   A  M   (B  5  vB  =  C  ?   D     *E  T   E  y   F  J  F     G     H     ]I  W   I     6J  T   )K  D   ~K  y   K  _   =L  @   L  $   L  &   M     *M  1   M  +   M  )   N  *   AN     lN     }N  2   N  ?   N  0   O  >   6O  /   uO  /   O  4   O  -   
P  )   8P  -   bP  !   P  D   P     P  Z   Q      aQ  ,   Q  G   Q  *   Q  V   "R  0   yR  >   R  -   R  =   S     US     oS     =T  J   T  9   <U  *   vU  <   U  0   U  #   V  )   3V  D   ]V  q   V  q   W  s   W     W      X     X     X  D   X     Y     Y  G   Y  >   Y  i   <Z  3   Z  k   Z  2   F[  @   y[  q   [     ,\  #   \  ,   \     \  Y   ]  @   ]  (   7^  0   `^  0  ^  U   _  X   `  b   q`  :   `     a     a  W   Zb     b  H   b  .   c    Gc  5   d  6    e     We  A   e  ?   ,f  \   lf  ~   f     Hg  @   g     h     h     i  ;   &i  7   bi  P   i  U   i     Aj  \   aj  .   j     j     
k  J   "k     mk     rk  :   {k  w   k  %   .l     Tl  3   nl  *   l  R   l  (    m  6   Im  .   m  .   m  .   m  0   
n  U   >n  0   n  C   n     	o  )   'o  $   Qo     vo  @   o  8   o  %   p  V   ,p     p  !   p  =   p     p  <   q  7   Oq     q     2r  =   Rr  &   r  !   r  Q   r  O   +s     {s  -   s     s     s  $   s  #   s     "t  %   Bt  	   ht     rt     t  F   !u  /   hu  L   u  H   u  x   .v  W   v     v  ,   w  -   w  V   w    3x     Cy     Ry           O             $                                      w             >   u   d                    -            Y       i         j            +   y                     G   
                 e   ;                              =          Z                h         	         E   *                 I   x      W   k             "   
                          r   2      S   [   @      9   D              .              8      '   )      `                                           B      g       C   m         q          0      6       X      b       #   z   s   %   p       N   F   H       _   ?      ]          c   5              l   7   A                  1             M   V   L   P       |                        \   }   R      K   :   <       o           3   n   {                                   /                                      T   ^          U   Q   ,      f   &   J                  v   !      4                      t   ~       (       a      ay  D  X  l                     iy  $          y  5          y  H          z  2          Jz  /          {z  7          z  %       	   z  G          +{  F          s{  /          {  6          {  A           
Execution of xargs will continue now, and it will try to read its input and run commands; if this is not what you wanted to happen, please type the end-of-file keystroke.
       --help                   display this help and exit
       --process-slot-var=VAR   set environment variable VAR in child processes
       --show-limits            show limits on command-line length
   -0, --null                   items are separated by a null, not whitespace;
                                 disables quote and backslash processing and
                                 logical EOF processing
   -E END                       set logical EOF string; if END occurs as a line
                                 of input, the rest of the input is ignored
                                 (ignored if -0 or -d was specified)
   -I R                         same as --replace=R
   -L, --max-lines=MAX-LINES    use at most MAX-LINES non-blank input lines per
                                 command line
   -P, --max-procs=MAX-PROCS    run at most MAX-PROCS processes at a time
   -a, --arg-file=FILE          read arguments from FILE, not standard input
   -d, --delimiter=CHARACTER    items in input stream are separated by CHARACTER,
                                 not by whitespace; disables quote and backslash
                                 processing and logical EOF processing
   -e, --eof[=END]              equivalent to -E END if END is specified;
                                 otherwise, there is no end-of-file string
   -l[MAX-LINES]                similar to -L but defaults to at most one non-
                                 blank input line if MAX-LINES is not specified
   -n, --max-args=MAX-ARGS      use at most MAX-ARGS arguments per command line
   -p, --interactive            prompt before running commands
   -r, --no-run-if-empty        if there are no arguments, then do not run COMMAND;
                                 if this option is not given, COMMAND will be
                                 run at least once
   -s, --max-chars=MAX-CHARS    limit length of command line to MAX-CHARS
   -t, --verbose                print commands before executing them
   -x, --exit                   exit if the size (see -s) is exceeded
 %s is an slocate database of unsupported security level %d; skipping it. %s is an slocate database.  Turning on the '-e' option. %s is not the name of a known user %s is not the name of an existing group %s is not the name of an existing group and it does not look like a numeric group ID because it has the unexpected suffix %s %s terminated by signal %d %s: exited with status 255; aborting %s: stopped by signal %d %s: terminated by signal %d < %s ... %s > ?  All Filenames: %s
 Cannot close standard input Cannot obtain birth time of file %s Cannot open input file %s Cannot read mounted file system list Cannot set SIGUSR1 signal handler Cannot set SIGUSR2 signal handler Compression ratio %4.2f%% (higher is better)
 Compression ratio is undefined
 Database %s is in the %s format.
 Database was last modified at %s.%09ld Empty argument to the -D option. Environment variable %s is not set to a valid decimal number Eric B. Decker Expected a positive decimal integer argument to %s, but got %s Expected an integer: %s Failed to fully drop privileges Failed to initialize shared-file hash table Failed to read from stdin Failed to save working directory in order to run a command on %s Failed to write output (at stage %d) Failed to write prompt for -ok Failed to write to standard output Failed to write to stderr Features enabled:  File descriptor %d will leak; please report this as a bug, remembering to include a detailed description of the simplest way to reproduce this problem. File names have a cumulative length of %s bytes.
Of those file names,

	%s contain whitespace, 
	%s contain newline characters, 
	and %s contain characters with the high bit set.
 File system loop detected; %s is part of the same file system loop as %s. I cannot figure out how to interpret %s as a date or time Ignoring unrecognised debug flag %s In %s the %s must appear by itself, but you specified %s Invalid argument %s for option --max-database-age Invalid argument %s to -used Invalid argument `%s%s' to -size Invalid escape sequence %s in input delimiter specification. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lo. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lx. Invalid escape sequence %s in input delimiter specification; trailing characters %s not recognised. Invalid input delimiter specification %s: the delimiter must be either a single character or an escape sequence starting with \. Invalid optimisation level %s James Youngman Kevin Dalley Locate database size: %s byte
 Locate database size: %s bytes
 Mandatory and optional arguments to long options are also
mandatory or optional for the corresponding short option.
 Matching Filenames: %s
 Old-format locate database %s is too short to be valid Only one instance of {} is supported with -exec%s ... + Optimisation level %lu is too high.  If you want to find files very quickly, consider using GNU locate. Please specify a decimal number immediately after -O Run COMMAND with arguments INITIAL-ARGS and more arguments read from input.

 Security level %s has unexpected suffix %s. Security level %s is outside the convertible range. Some filenames may have been filtered out, so we cannot compute the compression ratio.
 Symbolic link %s is part of a loop in the directory hierarchy; we have already visited the directory to which it points. The %s test needs an argument The -O option must be immediately followed by a decimal integer The -delete action automatically turns on -depth, but -prune does nothing when -depth is in effect.  If you want to carry on anyway, just explicitly use the -depth option. The -show-control-chars option takes a single argument which must be 'literal' or 'safe' The argument for option --max-database-age must not be empty The argument to -user should not be empty The atexit library function failed The current directory is included in the PATH environment variable, which is insecure in combination with the %s action of find.  Please remove the current directory from your $PATH (that is, remove ".", doubled colons, or leading or trailing colons) The database has big-endian machine-word encoding.
 The database has little-endian machine-word encoding.
 The database machine-word encoding order is not obvious.
 The environment is too large for exec(). The environment variable FIND_BLOCK_SIZE is not supported, the only thing that affects the block size is the POSIXLY_CORRECT environment variable The relative path %s is included in the PATH environment variable, which is insecure in combination with the %s action of find.  Please remove that entry from $PATH This system does not provide a way to find the birth time of a file. Unexpected suffix %s on %s Unknown regular expression type %s; valid types are %s. Usage: %s [-0 | --null] [--version] [--help]
 Usage: %s [-d path | --database=path] [-e | -E | --[non-]existing]
      [-i | --ignore-case] [-w | --wholename] [-b | --basename] 
      [--limit=N | -l N] [-S | --statistics] [-0 | --null] [-c | --count]
      [-P | -H | --nofollow] [-L | --follow] [-m | --mmap] [-s | --stdio]
      [-A | --all] [-p | --print] [-r | --regex] [--regextype=TYPE]
      [--max-database-age D] [--version] [--help]
      pattern...
 Usage: %s [OPTION]... COMMAND [INITIAL-ARGS]...
 WARNING: Lost track of %lu child processes WARNING: a NUL character occurred in the input.  It cannot be passed through in the argument list.  Did you mean to use the --null option? WARNING: cannot determine birth time of file %s WARNING: file %s appears to have mode 0000 WARNING: locate database %s was built with a different byte order Warning: %s will be run at least once.  If you do not want that to happen, then press the interrupt keystroke.
 You may not use {} within the utility name for -execdir and -okdir, because this is a potential security problem. You need to specify a security level as a decimal integer. You specified the -E option, but that option cannot be used with slocate-format databases with a non-zero security level.  No results will be generated for this database.
 argument line too long argument list too long argument to -group is empty, but should be a group name arithmetic overflow when trying to calculate the end of today arithmetic overflow while converting %s days to a number of seconds can't call exec() due to argument size restrictions cannot delete %s cannot fit single argument within argument list size limit cannot fork cannot search %s command too long could not create pipe before fork days double environment is too large for exec errno-buffer safe_read failed in xargs_do_exec (this is probably a bug, please report it) error reading a word from %s error waiting for %s error waiting for child process error: %s at end of format string error: the format directive `%%%c' is reserved for future use expected an expression after '%s' expected an expression between '%s' and ')' failed to drop group privileges failed to drop setgid privileges failed to drop setuid privileges failed to open /dev/tty for reading failed to restore working directory after searching %s failed to set environment variable %s failed to unset environment variable %s getfilecon failed: %s invalid -size type `%c' invalid argument `%s' to `%s' invalid expression invalid expression; I was expecting to find a ')' somewhere but did not see one. invalid expression; empty parentheses are not allowed. invalid expression; you have too many ')' invalid expression; you have used a binary operator '%s' with nothing before it. invalid mode %s invalid null argument to -size invalid predicate -context: SELinux is not enabled. invalid predicate `%s' locate database %s contains a filename longer than locate can handle locate database %s is corrupt or invalid locate database %s looks like an slocate database but it seems to have security level %c, which GNU findutils does not currently support missing argument to `%s' oops -- invalid default insertion of and! oops -- invalid expression type (%d)! oops -- invalid expression type! option --%s may not be set to a value which includes `=' sanity check of the fnmatch() library function failed. single slocate security level %ld is unsupported. standard error standard output time system call failed unexpected EOF in %s unexpected extra predicate unexpected extra predicate '%s' unknown unknown predicate `%s' unmatched %s quote; by default quotes are special to xargs unless you use the -0 option warning: -%s %s will not match anything because it ends with /. warning: escape `\' followed by nothing at all warning: format directive `%%%c' should be followed by another character warning: the -E option has no effect if -0 or -d is used.
 warning: the -d option is deprecated; please use -depth instead, because the latter is a POSIX-compliant feature. warning: the locate database can only be read from stdin once. warning: there is no entry in the predicate evaluation cost table for predicate %s; please report this as a bug warning: unrecognized escape `\%c' warning: unrecognized format directive `%%%c' warning: value %ld for -s option is too large, using %ld instead warning: you have specified a mode pattern %s (which is equivalent to /000). The meaning of -perm /000 has now been changed to be consistent with -perm -000; that is, while it used to match no files, it now matches all files. write error you have too many ')' Project-Id-Version: findutils 4.5.15
Report-Msgid-Bugs-To: bug-findutils@gnu.org
PO-Revision-Date: 2017-09-10 16:05+0200
Last-Translator: Mario Blättermann <mario.blaettermann@gmail.com>
Language-Team: German <translation-team-de@lists.sourceforge.net>
Language: de
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Bugs: Report translation errors to the Language-Team address.
Plural-Forms: nplurals=2; plural=n != 1;
X-Generator: Poedit 2.0.3
 
Ausführung von xargs wird nun fortgesetzt. Es wird versucht, dessen Eingabe zu lesen und Befehle auszuführen. Falls Sie dies nicht wollen, drücken Sie die Tastenkombination für end-of-file.
       --help                   diese Hilfe anzeigen und beenden
       --process-slot-var=VAR   setzt die Umgebungsvariable VAR in Unterprozessen
       --show-limits            zeigt Begrenzungen der Befehlszeilenlänge an
   -0, --null                   Objekte werden durch »null« und nicht durch Leer-
                                 zeichen getrennt; dies deaktiviert die Verarbeitung
                                 von Zitatzeichen, Backslashes und logischen Dateienden
                                 (EOF-Markierungen).
   -E ENDE                      setzt die logische EOF-Zeichenkette (Dateiende); falls
                                 ENDE als eine Zeile in der Eingabe auftritt, wird der
                                 Rest ignoriert (dies wird wiederum ignoriert, falls
                                 -0 oder -d angegeben war)
   -I R                         gleichbedeutend mit --replace=R
   -L, --max-lines=MAX-ZEILEN   höchstens MAX-ZEILEN als nicht-leere Eingabezeilen
                                 pro Befehlszeile verwenden
   -P, --max-procs=ANZAHL       höchstens diese ANZAHL Prozesse zugleich ausführen
   -a, --arg-file=DATEI         liest Argumente aus DATEI, nicht aus der
                                 Standardeingabe
   -d, --delimiter=ZEICHEN     Objekte in Eingabe-Datenströmen werden durch ZEICHEN
                                 getrennt und nicht durch Leerzeichen; dies deaktiviert
                                 die Verarbeitung von Zitatzeichen, Backslashes und
                                 logischen Dateienden (EOF-Markierungen).
   -e, --eof[=ENDE]             gleichbedeutend mit -E ENDE, sofern ENDE angegeben
                                 ist; anderenfalls gibt es keine Zeichenkette
                                 für end-of-file (EOF)
   -l[MAX-ZEILEN]               ähnlich wie -L, aber die Vorgabe ist höchstens eine
                                 leere Eingabezeile, wenn MAX-ZEILEN nicht angegeben ist.
   -n, --max-args=ANZAHL        höchstens diese ANZAHL Argumente in der
                                 Befehlszeile verwenden
   -p, --interactive            bittet vor der Ausführung von Befehlen um Bestätigung
   -r, --no-run-if-empty        falls keine Argumente angegeben sind, BEFEHL nicht
                                 ausführen; falls diese Option nicht angegeben ist,
                                 wird BEFEHL mindestens einmal ausgeführt
   -s, --max-chars=MAX-ZEICHEN  begrenzt die Länge der Befehlszeile auf MAX-ZEICHEN
   -t, --verbose                gibt Befehle vor der Ausführung aus
   -x, --exit                   beenden, falls die Größe überschritten ist
                                 (siehe -s)
 %s ist eine slocate-Datenbank der nicht unterstützten Sicherheitsstufe %d, wird übersprungen. %s ist eine slocate-Datenbank. Die Option »-e« wird aktiviert. %s ist ein unbekannter Benutzername. %s ist kein existierender Gruppenname. %s ist kein existierender Gruppenname und scheint auch keine numerische Gruppenbezeichnung zu sein, da sie die unerwartete Endung %s aufweist. Prozess %s wurde durch das Signal %d abgebrochen. %s: mit Rückgabewert 255 beendet, Abbruch. %s: wurde durch das Signal %d angehalten. %s: wurde durch das Signal %d abgebrochen. < %s ... %s > ?  Alle Dateinamen: %s
 Die Standardeingabe kann nicht geschlossen werden. Die Erstellungszeit der Datei %s konnte nicht ermittelt werden. Die Eingabedatei %s kann nicht geöffnet werden. Liste der eingehängten Dateisysteme kann nicht gelesen werden Signalhandler SIGUSR1 kann nicht gesetzt werden SIGUSR2-Signalhandler kann nicht gesetzt werden Kompressionsverhältnis %4.2f%% (höher ist besser)
 Das Kompressionsverhältnis ist undefiniert.
 Die Datenbank %s liegt im %s-Format vor.
 Datenbank wurde zuletzt um %s.%09ld geändert Fehlendes Argument zur Option -D. Umgebungsvariable %s ist nicht auf eine gültige Dezimalzahl gesetzt Eric B. Decker Eine positive dezimale Ganzzahl wird als Argument von %s erwartet, aber %s wurde erhalten. Eine Ganzzahl wurde erwartet: %s Verzichten auf alle Privilegien gescheitert. Initialisieren der dateiübergreifenden Hash-Tabelle ist fehlgeschlagen Lesen aus der Standardeingabe gescheitert. Arbeitsverzeichnis konnte nicht gespeichert werden, um einen Befehl in %s auszuführen Schreiben der Ausgabe gescheitert (bei Stufe %d) Schreiben in die Eingabeaufforderung für -ok ist gescheitert. Schreiben in die Standardausgabe gescheitert. Schreiben in den Fehlerkanal der Standardausgabe gescheitert. Aktivierte Eigenschaften: Dateideskriptor %d wird wird einen Überlauf verursachen. Bitte melden Sie dies als Fehler. Bitte fügen Sie eine detaillierte Beschreibung hinzu, wie dieser Fehler am einfachsten reproduziert werden kann. Die Dateinamen haben eine gesamte Länge von %s Byte.
Von diesen Dateinamen enthalten:

	%s Leerzeichen, 
	%s Zeilenumbrüche, 
	und %s enthalten Zeichen mit gesetztem hohem Bit.
 Dateisystemschleife erkannt; %s ist ein Teil der gleichen Schleife wie %s. %s konnte nicht als Datum oder Zeit interpretiert werden. Unerkanntes Debugsymbol %s wird ignoriert. In %s muss %s selbst erscheinen, aber Sie haben %s angegeben Ungültiges Argument %s für --max-database-age. Ungültiges Argument %s für -used. Ungültiges Argument »%s%s« für -size. Ungültige Escape-Sequenz %s in der Angabe des Eingabetrennzeichens. Ungültige Escape-Sequenz %s in der Angabe des Eingabetrennzeichens. Zeichenwerte dürfen %lo nicht übersteigen. Ungültige Escape-Sequenz %s in der Angabe des Eingabetrennzeichens. Zeichenwerte dürfen %lx nicht übersteigen. Ungültige Escape-Sequenz %s in der Angabe des Eingabetrennzeichens, angehängte Zeichen %s werden nicht anerkannt. Ungültige Angabe des Eingabetrennzeichens %s: Das Trennzeichen muss entweder ein einzelnes Zeichen oder eine mit \ beginnende Escape-Sequenz sein. Ungültige Optimierungsstufe %s. James Youngman Kevin Dalley Locate-Datenbankgröße: %s Byte
 Locate-Datenbankgröße: %s Bytes
 Obligatorische und optionale Argumente zu langen Optionen sind
ebenso obligatorisch oder optional für die entsprechenden
Kurzoptionen.
 Zutreffende Dateinamen: %s
 Die Datenbank %s im alten locate-Format ist zu kurz, um gültig zu sein Es wird nur eine Instanz von {} unterstützt mit -exec%s ... + Die Optimierungsstufe %lu ist zu hoch. Um schnell Dateien zu finden, ist GNU locate das bessere Werkzeug. Bitte eine Dezimalzahl unmittelbar nach -O angeben. Der BEFEHL wird mit den INITIAL-ARGUMENTEN und weiteren aus der Eingabe gelesenen Argumenten ausgeführt.

 Sicherheitsstufe %s hat das unerwartete Suffix %s. Sicherheitsstufe %s ist außerhalb des konvertierbaren Bereichs. Da einige Dateinamen ausgefiltert sein können, ist es nicht möglich, das
Kompressionsverhältnis zu berechnen.
 Der symbolische Link %s bildet eine Schleife in der Verzeichnishierarchie. Das bezeichnete Verzeichnis wurde bereits durchsucht. Der Test %s erfordert ein Argument. Auf die Option -O muss eine Ganzzahl folgen. Die Option -delete aktiviert -depth automatisch, aber -prune ist wirkungslos, wenn -depth aktiv ist. In diesem Fall muss -depth zusätzlich angegeben werden. Die Option -show-control-chars erfordert entweder »literal« oder »safe« als Argument. Das Argument der Option --max-database-age darf nicht leer sein. Die Option -user erfordert ein Argument. Die Bibiliotheksfunktion atexit ist gescheitert. Das aktuelle Verzeichnis ist in der Umgebungsvariable PATH enthalten. Dies ist bei der Kombination mit der Aktion %s von find unsicher. Entfernen Sie bitte das aktuelle Verzeichnis aus der $PATH-Variable, indem Punkte, Doppel-Doppelpunkte oder führende oder abschließende Doppelpunkte gelöscht werden. Die Datenbank hat die Big-Endian-Bytereihenfolge der Kodierung der Maschinenwörter.
 Die Datenbank hat die Little-Endian-Bytereihenfolge der Kodierung der Maschinenwörter.
 Die Bytereihenfolge der Kodierung der Maschinenwörter in der Datenbank ist nicht offensichtlich.
 Der benötigte Umgebungsspeicher ist für exec() zu groß. Die Umgebungsvariable FIND_BLOCK_SIZE wird nicht unterstützt. Die einzige Variante zur Beeinflussung der Blockgröße ist die Umgebungsvariable POSIXLY_CORRECT. Der relative Pfad %s ist in der Umgebungsvariable PFAD enthalten. Dies ist bei Verwendung der Aktion %s von find unsicher. Entfernen Sie bitte diesen Eintrag aus $PATH. Dieses System stellt keine Funktion zum Ermitteln der Erstellungszeit der Datei bereit. Unerwartete Endung %s an %s. Unbekannter Typ %s für den regulären Ausdruck. Gültige Typen sind %s. Aufruf: %s [-0 | --null] [--version] [--help]
 Aufruf: %s [-d Pfad | --database=Pfad] [-e | -E | --[non-]existing]
      [-i | --ignore-case] [-w | --wholename] [-b | --basename] 
      [--limit=N | -l N] [-S | --statistics] [-0 | --null] [-c | --count]
      [-P | -H | --nofollow] [-L | --follow] [-m | --mmap ] [ -s | --stdio ]
      [-A | --all] [-p | --print] [-r | --regex ] [--regextype=TYP]
      [--max-database-age D] [--version] [--help]
      Muster...
 Aufruf: %s [OPTION]... BEFEHL [INITIAL-ARGUMENTE]...
 WARNUNG: Verfolgung von %lu Kindprozessen ist verloren WARNUNG: Ein NUL-Zeichen trat in der Eingabe auf. Es kann nicht in die Argumentliste durchgegeben werden. Wollten Sie die Option --null verwenden? Warnung: Die Erstellungszeit der Datei %s ist nicht zu ermitteln. Warnung: Die Datei %s scheint die Zugriffsrechte 0000 zu haben. Warnung:  Die locate-Datenbank %s wurde mit einer unterschiedlichen Bytereihenfolge erzeugt. Warnung: %s wird mindestens einmal ausgeführt. Wenn Sie dies nicht wollen, drücken Sie die Tastenkombination zum Abbrechen.
 Innerhalb eines Befehlsnamens für -execdir und -okdir sollte {} nicht verwendet werden, da es ein mögliches Sicherheitsrisiko ist. Sie müssen eine Sicherheitsstufe als dezimale Ganzzahl angeben. Sie haben die Option -E angegeben, diese kann aber mit einer slocate-formatierten Datenbank einer von Null verschiedenen Sicherheitsstufe nicht verwendet werden. Für diese Datenbank werden keine Ergebnisse erstellt.
 Die Argumentzeile ist zu lang. Die Argumentliste ist zu lang. Das Argument zu -group fehlt. Es muss ein Gruppenname sein. Arithmetischer Überlauf beim Berechnen des Tagesendes. Arithmetischer Überlauf beim Konvertieren von %s Tagen in deren Sekundenanzahl. exec() kann aufgrund von Einschränkungen der Argumentgröße nicht aufgerufen werden %s kann nicht gelöscht werden. Ein einzelnes Argument kann nicht innerhalb der Grenzen der Argumentliste eingefügt werden. Es konnte kein neuer Prozess gestartet werden. %s kann nicht gesucht werden Der Befehl ist zu lang. Pipe vor dem Starten des Unterprozesses (fork) konnte nicht erzeugt werden Tage doppelte Der Umgebungsspeicher ist für »exec« nicht ausreichend. safe_read im errno-Puffer fehlgeschlagen in xargs_do_exec (dies ist möglicherweise ein Fehler, den Sie melden sollten) Fehler beim Lesen eines Worts von %s. Fehler beim Warten auf %s Fehler beim Warten auf das Ende des Unterprozesses. Fehler: %s am Ende der Formatzeichenkette. Fehler:  Die Formatanweisung »%%%c« ist für zukünftige Anwendungen reserviert. Ein Ausdruck wurde nach »%s« erwartet. Ein Ausdruck wurde zwischen »%s« und »)« erwartet. Verzichten auf Gruppenprivilegien gescheitert. Verzichten auf Setgid-Privilegien gescheitert. Verzichten auf Setuid-Privilegien gescheitert. /dev/tty konnte nicht zum Lesen geöffnet werden Die Rückkehr zum Arbeitsverzeichnis war nach dem Suchen nach %s nicht mehr möglich. Umgebungsvariable %s konnte nicht gesetzt werden Gesetzte Umgebungsvariable %s konnte nicht unwirksam gemacht werden getfilecon fehlgeschlagen: %s Ungültige Einheit »%c« für »-size«. Ungültiges Argument %s für »%s«. Ungültiger Ausdruck. ungültiger Ausdruck; »)« wurde erwartet, aber nicht gefunden. ungültiger Ausdruck; leere Klammern sind nicht erlaubt. Ungültiger Ausdruck; zu viele »)«. Ungültiger Ausdruck:  Ein binärer Operator »%s« wurde ohne Argument davor benutzt. Ungültiger Modus %s. »-size« erfordert ein Argument. Ungültige Eigenschaft -context: SELinux ist nicht aktiviert. ungültige Option »%s« Die locate-Datenbank %s enthält einen zu langen Dateinamen. Die locate-Datenbank %s ist beschädigt oder ungültig. Die locate-Datenbank %s sieht wie eine slocate-Datenbank aus, scheint aber Sicherheitsstufe %c zu haben, die durch die GNU findutils gegenwärtig nicht unterstützt wird. Fehlendes Argument für »%s«. Oops -- Das automatische Einfügen von »and« ist ungültig! Oops -- ungültiger Ausdruckstyp (%d)! Oops -- ungültiger Ausdruckstyp! Die Option --%s darf nicht auf einen Wert gesetzt werden, der ein »=« enthält. Die Plausibilitätsprüfung der Bibiliotheksfunktion fnmatch() ist gescheitert. einfache Sicherheitsstufe %ld wird nicht unterstützt. Standard-Fehlerausgabe Standardausgabe time-Systemaufruf ist fehlgeschlagen Unerwartetes Dateiende (EOF) in %s. Ungültige zusätzliche Option. ungültige zusätzliche Option »%s« unbekannt unbekannte Option »%s« Fehlendes korrespondierendes Anführungszeichen %s; per Vorgabe sind Anführungszeichen für xargs bestimmt, sofern Sie nicht die Option -O verwenden Warnung: -%s %s wird keine Übereinstimmung finden, da es auf / endet. Warnung: Auf Escape-Zeichen »\« folgt nichts. Warnung: Auf die Formatanweisung »%%%c« sollte ein weiteres Zeichen folgen Warnung: Die Option -E ist wirkungslos, wenn -0 oder -d verwendet wird.
 Warnung:  Die Option -d soll nicht mehr verwendet werden. Statt dessen steht das POSIX-kompatible -depth zur Verfügung. Warnung: Die Locate-Datenbank kann nur einmalig aus der Standardeingabe gelesen werden. Warnung: Es gibt keinen Eintrag in der »predicate evaluation cost table« für Eigenschaft %s; bitte melden Sie dies als Fehler. Warnung: Unerkanntes Escape-Zeichen »\%c«. Warnung: Unerkannte Formatanweisung »%%%c«. Warnung: Der Wert %ld für die Option -s ist zu groß, stattdessen wird %ld verwendet. Warnung: Eine Bezeichnung für Zugriffsrechte %s wurde angegeben, die gleichbedeutend mit /000 ist. Die Bedeutung von -perm /000 wurde jetzt geändert, um mit der Verwendung von -perm -000 konsistent zu sein. Deshalb trifft es jetzt auf alle Dateien zu, vorher auf keine. Schreibfehler. zu viele »)« PRIuMAX Your environment variables take up % bytes
 POSIX upper limit on argument length (this system): %
 POSIX smallest allowable upper limit on argument length (all systems): %
 Maximum length of command we could actually use: %
 Size of command buffer we are actually using: %
 Maximum parallelism (--max-procs must be no greater): %
 Die Umgebungsvariablen beanspruchen % Bytes.
 In POSIX erlaubte Obergrenze der Argumentlänge (für dieses System): %
 In POSIX erlaubte Obergrenze für die Argumentlänge (alle Systeme): %
 Maximale tatsächlich nutzbare Befehlslänge: %
 Größe des tatsächlich verwendeten Befehlspuffers: %
 Maximaler Parallelismus (--max-procs darf nicht größer sein): %
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        0                   ,      4     5  :     O     B   m            3   e  }     I     L   a               -  O     >        [  I   0  D   z  E     H     7   N  "     '     |        N  $   i                           #        '  $   A  !   f  !     -          !     &         A  <   b       >               +   %     Q  @   k  $          "             -     @       I      9      #   !  8   4!  1   m!     !      !  <   !  b   "  b   }"  c   "     D#     #     #     #  >   #  t   >$     $  6   $  7   %  g   :%  4   %  M   %  +   %&  3   Q&  W   &  x   &     V'  ?   t'     '  X   `(  <   (  )   (  "    )     C)  3   >*  6   r*  9   *  (   *     +     +  D   C,     ,  7   ,  -   ,    	-  0   .  *   .     /  /   /  *   /  A   /  o   -0  q   0  :   1     J1     1     
2  7   $2  =   \2  C   2  3   2     3  :   #3     ^3     j3     {3  !   3     3     3  !   3  Y   3     64     S4     h4  !   4  =   4  !   4  +   
5     65      V5      w5  #   5  6   5  %   5  '   6     A6     W6     o6     6  P   6  6   6  )   (7  P   R7     7     7  3   7     8  D   8  (   b8     8     9  )   -9  %   W9      }9  8   9  6   9     :  *   :     @:     O:     _:     w:     :     :     :     :  W   :  ?   >;  .   ~;  H   ;  :   ;  q   1<  >   <  o   <  "   R=  -   u=  @   =     =     >     >    >  *  @  l   A     OB  W   B    BC     YD  >   :E     yE  i   F     F  R  G     dH     I  s   J  Q   J  ?  J  N   L  o   lL  c   L     @M  f   M  @   HN  A   N     N  3   O  W   O  .   -P  5   \P     P  .   P  D   P  c   Q  F   {Q  o   Q  ?   2R  ?   rR  g   R  G   S  A   bS  P   S  1   S  w   'T     T  e   T  )   U  E   >U  6   U  .   U  u   U  O   `V     V  8   V  /   W     8W     KW  G  =X     Y  w   Z  O   Z  g   Z  L   G[  .   [  C   [     \     \     k]     N^    '_  B   -`     p`     `     `     a  >   b     Gb  a   b     /c  ]   c     Sd  c   d  n   Fe     e     f  "   yg  n   g  3  h     ?i  i   i  \   ?j  B   j    j  M   al  P   l  9    m  I   :m     m  T  xn     o  9   `p  m   p  2   q    ;q  B   r  i   #s    s  ~   t  Y   %u  ~   u     u     v  t   w     x  5   x  3   x  w   0y  ~   y     'z  {   z  &   /{     V{  -   {  (   )|  $   R|  A   w|  
   |  
   |  Y   |     )}  B   }  /   ~  N   D~  X   ~  v   ~  ?   c  A     E     ?   +  =   k  H     u     R   h  i        %  O   E  L           p     k   t  >          $     O   ڄ  h   *  ?        Ӆ  x   h       ;   އ  u     =     8   Έ  n     y   v       P        J     Y  7   i  ?     6     =        V  :   e       t   j  .   ߌ       x        /     ώ  o   T  i   ď  Y   .                               O             $                                      w             >   u   d                    -            Y       i         j            +   y                     G   
                 e   ;                              =          Z                h         	         E   *                 I   x      W   k             "   
                          r   2      S   [   @      9   D              .              8      '   )      `                                           B      g       C   m         q          0      6       X      b       #   z   s   %   p       N   F   H       _   ?      ]          c   5              l   7   A                  1             M   V   L   P       |                        \   }   R      K   :   <       o           3   n   {                                   /                                      T   ^          U   Q   ,      f   &   J                  v   !      4                      t   ~       (       a      4  D  X  l                     <  $          h  5            H            2            /          N  7            Q            T          6            є  r          E  K            X           
Execution of xargs will continue now, and it will try to read its input and run commands; if this is not what you wanted to happen, please type the end-of-file keystroke.
       --help                   display this help and exit
       --process-slot-var=VAR   set environment variable VAR in child processes
       --show-limits            show limits on command-line length
   -0, --null                   items are separated by a null, not whitespace;
                                 disables quote and backslash processing and
                                 logical EOF processing
   -E END                       set logical EOF string; if END occurs as a line
                                 of input, the rest of the input is ignored
                                 (ignored if -0 or -d was specified)
   -I R                         same as --replace=R
   -L, --max-lines=MAX-LINES    use at most MAX-LINES non-blank input lines per
                                 command line
   -P, --max-procs=MAX-PROCS    run at most MAX-PROCS processes at a time
   -a, --arg-file=FILE          read arguments from FILE, not standard input
   -d, --delimiter=CHARACTER    items in input stream are separated by CHARACTER,
                                 not by whitespace; disables quote and backslash
                                 processing and logical EOF processing
   -e, --eof[=END]              equivalent to -E END if END is specified;
                                 otherwise, there is no end-of-file string
   -l[MAX-LINES]                similar to -L but defaults to at most one non-
                                 blank input line if MAX-LINES is not specified
   -n, --max-args=MAX-ARGS      use at most MAX-ARGS arguments per command line
   -p, --interactive            prompt before running commands
   -r, --no-run-if-empty        if there are no arguments, then do not run COMMAND;
                                 if this option is not given, COMMAND will be
                                 run at least once
   -s, --max-chars=MAX-CHARS    limit length of command line to MAX-CHARS
   -t, --verbose                print commands before executing them
   -x, --exit                   exit if the size (see -s) is exceeded
 %s is an slocate database of unsupported security level %d; skipping it. %s is an slocate database.  Turning on the '-e' option. %s is not the name of a known user %s is not the name of an existing group %s is not the name of an existing group and it does not look like a numeric group ID because it has the unexpected suffix %s %s terminated by signal %d %s: exited with status 255; aborting %s: stopped by signal %d %s: terminated by signal %d < %s ... %s > ?  All Filenames: %s
 Cannot close standard input Cannot obtain birth time of file %s Cannot open input file %s Cannot read mounted file system list Cannot set SIGUSR1 signal handler Cannot set SIGUSR2 signal handler Compression ratio %4.2f%% (higher is better)
 Compression ratio is undefined
 Database %s is in the %s format.
 Database was last modified at %s.%09ld Empty argument to the -D option. Environment variable %s is not set to a valid decimal number Eric B. Decker Expected a positive decimal integer argument to %s, but got %s Expected an integer: %s Failed to fully drop privileges Failed to initialize shared-file hash table Failed to read from stdin Failed to save working directory in order to run a command on %s Failed to write output (at stage %d) Failed to write prompt for -ok Failed to write to standard output Failed to write to stderr Features enabled:  File descriptor %d will leak; please report this as a bug, remembering to include a detailed description of the simplest way to reproduce this problem. File names have a cumulative length of %s bytes.
Of those file names,

	%s contain whitespace, 
	%s contain newline characters, 
	and %s contain characters with the high bit set.
 File system loop detected; %s is part of the same file system loop as %s. I cannot figure out how to interpret %s as a date or time Ignoring unrecognised debug flag %s In %s the %s must appear by itself, but you specified %s Invalid argument %s for option --max-database-age Invalid argument %s to -used Invalid argument `%s%s' to -size Invalid escape sequence %s in input delimiter specification. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lo. Invalid escape sequence %s in input delimiter specification; character values must not exceed %lx. Invalid escape sequence %s in input delimiter specification; trailing characters %s not recognised. Invalid input delimiter specification %s: the delimiter must be either a single character or an escape sequence starting with \. Invalid optimisation level %s James Youngman Kevin Dalley Locate database size: %s byte
 Locate database size: %s bytes
 Mandatory and optional arguments to long options are also
mandatory or optional for the corresponding short option.
 Matching Filenames: %s
 Old-format locate database %s is too short to be valid Only one instance of {} is supported with -exec%s ... + Optimisation level %lu is too high.  If you want to find files very quickly, consider using GNU locate. Please specify a decimal number immediately after -O Run COMMAND with arguments INITIAL-ARGS and more arguments read from input.

 Security level %s has unexpected suffix %s. Security level %s is outside the convertible range. Some filenames may have been filtered out, so we cannot compute the compression ratio.
 Symbolic link %s is part of a loop in the directory hierarchy; we have already visited the directory to which it points. The %s test needs an argument The -O option must be immediately followed by a decimal integer The -delete action automatically turns on -depth, but -prune does nothing when -depth is in effect.  If you want to carry on anyway, just explicitly use the -depth option. The -show-control-chars option takes a single argument which must be 'literal' or 'safe' The argument for option --max-database-age must not be empty The argument to -user should not be empty The atexit library function failed The current directory is included in the PATH environment variable, which is insecure in combination with the %s action of find.  Please remove the current directory from your $PATH (that is, remove ".", doubled colons, or leading or trailing colons) The database has big-endian machine-word encoding.
 The database has little-endian machine-word encoding.
 The database machine-word encoding order is not obvious.
 The environment is too large for exec(). The environment variable FIND_BLOCK_SIZE is not supported, the only thing that affects the block size is the POSIXLY_CORRECT environment variable The relative path %s is included in the PATH environment variable, which is insecure in combination with the %s action of find.  Please remove that entry from $PATH This system does not provide a way to find the birth time of a file. Unexpected suffix %s on %s Unknown regular expression type %s; valid types are %s. Usage: %s [-0 | --null] [--version] [--help]
 Usage: %s [-d path | --database=path] [-e | -E | --[non-]existing]
      [-i | --ignore-case] [-w | --wholename] [-b | --basename] 
      [--limit=N | -l N] [-S | --statistics] [-0 | --null] [-c | --count]
      [-P | -H | --nofollow] [-L | --follow] [-m | --mmap] [-s | --stdio]
      [-A | --all] [-p | --print] [-r | --regex] [--regextype=TYPE]
      [--max-database-age D] [--version] [--help]
      pattern...
 Usage: %s [OPTION]... COMMAND [INITIAL-ARGS]...
 WARNING: Lost track of %lu child processes WARNING: a NUL character occurred in the input.  It cannot be passed through in the argument list.  Did you mean to use the --null option? WARNING: cannot determine birth time of file %s WARNING: file %s appears to have mode 0000 WARNING: locate database %s was built with a different byte order Warning: %s will be run at least once.  If you do not want that to happen, then press the interrupt keystroke.
 You may not use {} within the utility name for -execdir and -okdir, because this is a potential security problem. You need to specify a security level as a decimal integer. You specified the -E option, but that option cannot be used with slocate-format databases with a non-zero security level.  No results will be generated for this database.
 argument line too long argument list too long argument to -group is empty, but should be a group name arithmetic overflow when trying to calculate the end of today arithmetic overflow while converting %s days to a number of seconds can't call exec() due to argument size restrictions cannot delete %s cannot fit single argument within argument list size limit cannot fork cannot search %s command too long could not create pipe before fork days double environment is too large for exec errno-buffer safe_read failed in xargs_do_exec (this is probably a bug, please report it) error reading a word from %s error waiting for %s error waiting for child process error: %s at end of format string error: the format directive `%%%c' is reserved for future use expected an expression after '%s' expected an expression between '%s' and ')' failed to drop group privileges failed to drop setgid privileges failed to drop setuid privileges failed to open /dev/tty for reading failed to restore working directory after searching %s failed to set environment variable %s failed to unset environment variable %s getfilecon failed: %s invalid -size type `%c' invalid argument `%s' to `%s' invalid expression invalid expression; I was expecting to find a ')' somewhere but did not see one. invalid expression; empty parentheses are not allowed. invalid expression; you have too many ')' invalid expression; you have used a binary operator '%s' with nothing before it. invalid mode %s invalid null argument to -size invalid predicate -context: SELinux is not enabled. invalid predicate `%s' locate database %s contains a filename longer than locate can handle locate database %s is corrupt or invalid locate database %s looks like an slocate database but it seems to have security level %c, which GNU findutils does not currently support missing argument to `%s' oops -- invalid default insertion of and! oops -- invalid expression type (%d)! oops -- invalid expression type! option --%s may not be set to a value which includes `=' sanity check of the fnmatch() library function failed. single slocate security level %ld is unsupported. standard error standard output time system call failed unexpected EOF in %s unexpected extra predicate unexpected extra predicate '%s' unknown unknown predicate `%s' unmatched %s quote; by default quotes are special to xargs unless you use the -0 option warning: -%s %s will not match anything because it ends with /. warning: escape `\' followed by nothing at all warning: format directive `%%%c' should be followed by another character warning: the -E option has no effect if -0 or -d is used.
 warning: the -d option is deprecated; please use -depth instead, because the latter is a POSIX-compliant feature. warning: the locate database can only be read from stdin once. warning: there is no entry in the predicate evaluation cost table for predicate %s; please report this as a bug warning: unrecognized escape `\%c' warning: unrecognized format directive `%%%c' warning: value %ld for -s option is too large, using %ld instead warning: you have specified a mode pattern %s (which is equivalent to /000). The meaning of -perm /000 has now been changed to be consistent with -perm -000; that is, while it used to match no files, it now matches all files. write error you have too many ')' Project-Id-Version: findutils-4.5.15
Report-Msgid-Bugs-To: bug-findutils@gnu.org
PO-Revision-Date: 2021-01-10 22:17+0200
Last-Translator: Lefteris Dimitroulakis <ledimitro@gmail.com>
Language-Team: Greek <team@lists.gnome.gr>
Language: el
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Bugs: Report translation errors to the Language-Team address.
X-Generator: Poedit 2.4.2
Plural-Forms: nplurals=2; plural=(n != 1);
 
Η εκτέλεση του xargs θα συνεχιστεί τώρα, και θα προσπαθήσει να διαβάσει την είσοδό του και να τρέξει εντολές· αν δεν είναι αυτό που θέλεις να συμβεί, παρακαλώ δώσε EOF.
       --help                   εμφάνιση αυτής εδώ της βοήθειας κι έξοδος
   --process-slot-var=VAR  ενεργοποίηση μεταβλητής περιβάλλοντος VAR στις θυγατρικές διεργασίες
       --show-limits            εμφάνιση ορίου μήκους εντολής
   -0, --null                   items χωρίζονται από κενό, όχι λευκό διάστημα,
                                 απενεργοποιεί quote και backslash processing όπως
                                 και logical EOF processing.
   -E END                       Set logical EOF string; if END occurs as a line
                                 of input, the rest of the input is ignored
                                 (ignored if -0 or -d was specified)
   -I R                         το ίδιο με --replace=R
   -L, --max-lines=MAX-LINES   χρήση το πολύ MAX-LINES μη κενές γραμμές ανά
                                 γραμμή εντολής
   -P, --max-procs=MAX-PROCS   τρέξε συγχρόνως το πολύ MAX-PROCS διεργασίες
   -a, --arg-file=FILE   ανάγνωση ορισμάτων από το ΑΡΧΕΙΟ κι όχι απ' την τυπική είσοδο
   -d, --delimiter=ΧΑΡΑΚΤΗΡΑΣ    items στο ρεύμα εισόδου χωρίζονται από ΧΑΡΑΚΤΗΡΑ,
                                 όχι από λευκό διάστημα, απενεργοποιεί quote και backslash
                                 processing όπως και logical EOF processing
   -e, --eof[=END]    ισοδύναμο του -E END αν το END έχει οριστεί,
                                 αλλιώς, δεν υπάρχει end-of-file string
   -l[MAX-LINES]                αντίστοιχο του -L αλλά από προεπιλογή το πολύ μια μη-
                                 κενή γραμμή εισόδου αν MAX-LINES δεν είναι καθορισμένο
   -n, --max-args=MAX-ARGS    χρήση το πολύ MAX-ARGS ορίσματα ανά γραμμή εντολών
   -p, --interactive   ερώτηση πριν το τρέξιμο εντολών
   -r, --no-run-if-empty   αν δεν υπάρχουν ορίσματα, τότε μη τρέξεις την ΕΝΤΟΛΗ,
                                 αν δεν δίνεται αυτή η επιλογή, τότε η ΕΝΤΟΛΗ θα τρέξει
                                 τουλάχιστον άπαξ
   -s, --max-chars=MAX-CHARS    όριο μήκους εντολής MAX-CHARS
   -t, --verbose                εμφάνιση εντολών πριν απ' την εκτέλεσή τους
   -x, --exit   έξοδος αν το μέγεθος (βλέπε -s) έχει ξεπεραστεί
 %s είναι μια βάση δεδομένων slocate με μη υποστηριζόμενο επίπεδο ασφαλείας %d· παραλείπεται. %s σε μια βάση δεδομένων slocate.  Ενεργοποίηση επιλογής «-e». %s δεν είναι το όνομα γνωστού χρήστη %s δεν είναι όνομα υπάρχουσας ομάδας %s δεν αποτελεί όνομα υπάρχουσας ομάδας και δεν μιάζει με ένα αριθμητικό group ID γιατί έχει τη μη αναμενόμενη κατάληξη %s %s τερματίστηκε από το σήμα %d %s: τερματίστηκε με ένδειξη 255, απότομο σταμάτημα %s: σταμάτησε από το σήμα %d %s: τερματίστηκε από το σήμα  %d < %s ... %s > ?  Όλα τα ονόματα αρχείων: %s
 Δεν μπορώ να κλείσω την τυπική είσοδο Αδυναμία εύρεσης του χρόνου δημιουργίας του αρχείου %s Αδυναμία ανοίγματος αρχείου εισόδου %s Αδυναμία ανάγνωσης λίστας προσαρτημένου συστήματος αρχείων Αδυναμία ρύθμισης του SIGUSR1 signal handler Αδυναμία ρύθμισης του SIGUSR2 signal handler Συντελεστής συμπίεσης %4.2f%% (μεγαλύτερος είναι καλύτερα)
 Συντελεστής συμπίεσης απροσδιόριστος
 Η βάση δεδομένων %s είναι σε μορφή %s.
 Τελευταία τροποποίηση βάσης δεδομένων %s.%09ld Κενό όρισμα στην επιλογή -D. Η μεταβλητή περιβάλλοντος %s δε ρυθμίστηκε σε ένα δεκαδικό αριθμό Eric B. Decker Ανάμενα ως όρισμα του %s ένα θετικό ακέραιο, αλλά έλαβα %s Αναμενόταν ακέραιος: %s Αποτυχία ολικής κατάργησης προνομίων Αποτυχία ενεργοποίησης hash table Αδυναμία εγγραφής στη stdin Αποτυχία διάσωσης καταλόγου εργασίας ώστε να τρέξει εντολή σε %s Το γράψιμο στην έξοδο απέτυχε (στο στάδιο %d) Failed to write prompt for -ok Αδυναμία εγγραφής στη standard output Αδυναμία εγγραφής στη stderr Features enabled:  Διαρροή περιγραφέα αρχείου %d· παρακαλώ αναφέρατέ το ως bug, εσωκλείοντας λεπτομερή περιγραφή για τον απλούστερο τρόπο αναπαραγωγής. Τα ονόματα αρχείων έχουν ένα συνολικό μήκος %s bytes.
Από αυτά τα ονόματα,

	%s περιέχουν λευκό διάστημα, 
	%s περιέχουν χαρακτήρες νέας γραμμής, 
	και %s περιέχουν χαρακτήρες με το high bit set.
 Ανιχνεύτηκε βρόχος στο σύστημα αρχείων· %s αποτελεί μέρος του ιδίου βρόχου με %s. Δεν μπορώ να προσδιορίσω πώς να ερμηνεύσω %s ως ημερομηνία και ώρα Άγνωστη σημαία αποσφαλμάτωσης %s, αγνοήθηκε Στο %s, το %s πρέπει να εμφανίζεται μόνο του, αλλά ορίσατε %s Μη έγκυρο όρισμα %s στην επιλογή --max-database-age Μη έγκυρο όρισμα %s για -used Το όρισμα «%s» για την «%s» είναι άκυρο Μη έγκυρη ακολουθία διαφυγής %s στην προδιαγραφή του οριοθέτη εισόδου. Μη έγκυρη ακολουθία διαφυγής %s στην προδιαγραφή του οριοθέτη εισόδου· οι τιμές των χαρακτήρων δεν πρέπει να υπερβαίνουν %lo. Μη έγκυρη ακολουθία διαφυγής %s στην προδιαγραφή του οριοθέτη εισόδου· οι τιμές των χαρακτήρων δεν πρέπει να υπερβαίνουν %lx. Μη έγκυρη ακολουθία διαφυγής %s στην προδιαγραφή του οριοθέτη εισόδου· οι οι χαρακήρες στο τέλος %s δεν αναγνωρίζονται. Μη έγκυρη προδιαγραφή οριοθέτη εισόδου %s: ο οριοθέτης πρέπει να είναι είτε ένας μοναδικός χαρακτήρας ή μια ακολουθία διαφυγής που αρχίζει με \. Μη έγκυρο επίπεδο βελτιστοποίησης %s James Youngman Kevin Dalley Μέγεθος της βάσης δεδομένων locate: %s byte
 Μέγεθος της βάσης δεδομένων locate: %s bytes
 Υποχρεωτικά και προαιρετικά ορίσματα σε μακρές επιλογές είναι επίσης
υποχρεωτικά ή προαιρετικά για την αντίστοιχη κοντή επιλογή.
 Ονόματα αρχείων που ταιριάζουν: %s
 Η παλαιά μορφής βάση δεδομένων locate %s είναι πολύ μικρή για να είναι έγκυρη Εμφάνιση μόνο μια φορά των {} υποστηρίζεται με -exec%s ... + Επίπεδο βελτιστοποίησης %lu πολύ υψηλό.  Αν θέλετε να βρείτε αρχεία πολύ γρήγορα, εξετάστε τη χρήση του GNU locate. Παρακαλώ ορίσατε ένα δεκαδικό αριθμό αμέσως μετά -O Τρέξε την ΕΝΤΟΛΗ με ορίσματα INITIAL-ARGS και περισσότερα ορίσματα από την είσοδο.

 Το επίπεδο ασφαλείας %s έχει μη αναμενόμενη κατάληξη %s. Το επίπεδο ασφαλείας %s βρίσκεται εκτός περιοχής μετατροπής. Κάποια ονόματα αρχείων έχουν φιλτραριστεί και αφαιρεθεί, έτσι δεν μπορούμε ωα υπολογίσουμε το βαθμό συμπίεσης.
 Ο συμβολικός σύνδεσμος %s αποτελεί τμήμα ενός βρόχου στην ιεραρχία καταλόγων· έχομε ήδη επισκευτεί το κατάλογο στον οποίο αναφέρεται. «%s» απαιτεί όρισμα Την επιλογή -O πρέπει αμέσως να ακολουθεί δεκαδικός ακέραιος Η ενέργεια -delete αυτομάτως ενεργοποεί την -depth, όμως η -prune δεν κάνει τίποτα όταν η -depth είναι παρούσα.  Αν θες όμως να προχωρήσεις όπωσδήποτε, χρησιμοποίησε την επιλογή -depth. Η επιλογή -show-control-chars δέχεται ένα μοναδικό όρισμα που πρέπει να είναι «literal» ή «safe» Το όρισμα στην επολογή --max-database-age πρέπει να μην είναι κενό Το όρισμα στην επιλογή -user δεν πρέπει να είναι κενό Η συνάρτηση βιβλιοθήκης atexit απέτυχε Ο τρέχων κατάλογος περιλαμβάνεται στη μεταβλητή PATH, που σε συνδιασμό με την ενέργεια %s του find είναι ανασφαλές.  Παρακαλώ αφαίρέσατε τον τρέχοντα κατάλογο από την $PATH (δηλαδή, αφαίρεση ".", doubled colons, ή leading ή trailing colons) Η βάση δεδομένων έχει κωδικοποίηση big-endian.
 Η βάση δεδομένων έχει κωδικοποίηση little-endian.
 The database machine-word encoding order is not obvious.
 Το περιβάλλον είναι πολύ μεγάλο γιά exec(). Η μεταβλητή περιβάλλοντος FIND_BLOCK_SIZE δεν υποστηρίζεται, αυτό που επιρρεάζει το μέγεθος μπλοκ είναι η μεταβλητή περιβάλλοντος POSIXLY_CORRECT Η σχετική διαδρομή %s περιλαμβάνεται στη μεταβλητή περιβάλλοντος PATH, που που δεν είναι ασφαλής όταν συνδιάζεται με την ενέργεια %s του find. Παρακαλώ αφαιρέστε αυτή την καταχώρηση από τη $PATH Αυτό το σύστημα δεν διαθέτει τρόπο εύρεσης του χρόνου δημιουργίας ενός αρχείου. Μη αναμενόμενη κατάληξη %s στο %s Άγνωστος τύπος κανονικής έκφρασης %s· έγκυροι τύποι είναι %s. Χρήση: %s [-0 | --null] [--version] [--help]
 Χρήση: %s [-d path | --database=path] [-e | -E | --[non-]existing]
      [-i | --ignore-case] [-w | --wholename] [-b | --basename] 
      [--limit=N | -l N] [-S | --statistics] [-0 | --null] [-c | --count]
      [-P | -H | --nofollow] [-L | --follow] [-m | --mmap] [-s | --stdio]
      [-A | --all] [-p | --print] [-r | --regex] [--regextype=TYPE]
      [--max-database-age D] [--version] [--help]
      pattern...
 Χρήση: %s [ΕΠΙΛΟΓΗ]... ΕΝΤΟΛΗ [INITIAL-ARGS]...
 ΠΡΟΕΙΔΟΠΟΙΗΣΗ: Έχασα τα ίχνη των θυγατρικών διεργασιών %lu ΠΡΟΕΙΔΟΠΟΙΗΣΗ: ένας χαρακτήρας NUL βρέθηκε στην είσοδο.  Δεν μπορεί να περάσει στην στη λίστα ορισμάτων.  Μήπως εννοείς να χρησιμοποιήσεις την επιλογή --null; ΠΡΟΕΙΔΟΠΟΙΗΣΗ: αδυναμία καθορισμού χρόνου δημιουργίας του αρχείου %s ΠΡΟΕΙΔΟΠΟΙΗΣΗ: το αρχείο %s φαίνεται να έχει mode 0000 ΠΡΟΕΙΔΟΠΟΙΗΣΗ: η βάση δεδομένων locate %s φτιάχτηκε με διαφορετικό byte order Προειδοποίηση: %s θα τρέξει τουλάχιστον άπαξ.  Αν δεν θέλεις να συμβεί αυτό, πάτησε το πλήκτρο διακοπής.
 Δεν πρέπει να χρησιμοποιούνται {} μέσα στο όνομα του utility για -execdir και -okdir γιατί αυτό δημιουργεί δυνητικά ένα πρόβλημα ασφαλείας. Πρέπει να ορίσεις το επίπεδο ασφαλείας με ένα δεκαδικό ακέραιο. You specified the -E option, but that option cannot be used with slocate-format databases with a non-zero security level.  No results will be generated for this database.
 γραμμή ορισμάτων πολύ μεγάλη λίστα ορισμάτων πολύ μεγάλη το όρισμα στο -group είναι κενό, αλλά θα έπρεπε να είναι όνομα ομάδας αριθμητική υπερχείληση όταν προσπαθώ να υπολογίσω το σημερινό πέρας αριθμητική υπερχείληση κατά την μετατροπή %s ημερών σε αριθμό δευτερολέπτων αδυναμία κλήσης της exec() λόγω περιορισμών στο μέγεθος του ορίσματος αδυναμία διαγραφής %s δεν μπορώ να περιλάβω μοναδικό όρισμα μέσα
στο περιορισμένο μέγεθος της λίστας ορισμάτων δεν μπορώ να κλωνοποιήσω αδυναμία αναζήτησης %s διαταγή πολύ μεγάλη αδυναμία δημιουργίας pipe πριν από fork μέρες διπλά το περιβάλλον είναι πολύ μεγάλο γιά την εκτέλεση αποτυχία ανάγνωσης του errno-buffer στο xargs_do_exec (πιθανόν πρόκειται περί bug, παρακαλώ αναφέρατέ το) σφάλμα κατά την ανάγνωση λέξης από %s σφάλμα περιμένοντας γιά %s σφάλμα αναμένοντας τη θυγατρική διεργασία error: %s στο τέλος του αλφαρηθμιτικού μορφοποίησης error: η οδηγία μορφοποίησης «%%%c» προορίζεται για μελλοντική χρήση αναμενόταν μια έκφραση μετά το «%s» αναμενόταν expression μεταξύ «%s» και  «)» αποτυχία κατάργησης προνομίων ομάδας αποτυχία κατάργησης προνομίων setgid αποτυχία κατάργησης προνόμια setuid αδυναμία ανοίγματος /dev/tty προς ανάγνωση αποτυχία αποκατάστασης καταλόγου εργασίας μετά την αναζήτηση %s αποτυχία ορισμού μεταβλητής περιβάλλοντος %s αποτυχία απενεργοποίησης της μεταβλητής περιβάλλοντος %s αποτυχία getfilecon: %s ο τύπος «%c» για την επιλογή -size είναι άκυρος το όρισμα «%s» για την «%s» δεν είναι έγκυρο μη έγκυρη έκφραση μη έγκυρη έκφραση· περίμενα να βρω κάπου μια «)» αλλά ματαίως. μη έγκυρη έκφραση· ανοικτές παρενθέσεις δεν επιτρέπονται. μη έγκυρη έκφραση· πάρα πολλές «)» μη έγκυρη έκφραση· χρησιμοποιήσατε δυαδικό τελεστή «%s» χωρίς τίποτα μπροστά του. άκυρη κατάσταση «%s» το όρισμα null είναι άκυρο για την επιλογή -size μη έγκυρο κατηγόρημα -context: SELinux δεν είναι ενεργοποιημένο. το κατηγόρημα «%s» δεν είναι έγκυρο η βάση δεδομένων locate %s περιέχει όνομα αρχείου μεγαλύτερο από τις δυνατότητές της η βάση δεδομένων locate  «%s» δεν είναι έγκυρη ή έχει υποστεί αλλοίωση η βάση δεδομένων locate %s μιάζει με μια slocate αλλά φαίνεται να έχει επίπεδο ασφαλείας %c, το οποίο δεν υποστηρίζεται προς το παρόν από το GNU findutils το όρισμα για την «%s» απουσιάζει oops -- η παρεμβολή της προεπιλεγμένης παραμέτρου «and» είναι άκυρη! oops -- μη έγκυρος τύπος έκφρασης (%d)! oops -- μη έγκυρος τύπος έκφρασης! η επιλογή --%s δεν μπορεί να ρυθμιστεί σε τιμή που περιέχει «=» η συνάρτηση βιβλιοθήκης fnmatch(), δεν πέρασε τον έλεγχο ακεραιότητος. μονά επίπεδο ασφαλείας slocate %ld δεν υποστηρίζεται. standard error standard output αποτυχία κλήσης συστήματος time μη αναμενόμενο τέλος αρχείου στο %s μη αναμενόμενο extra κατηγόρημα μη αναμενόμενο extra κατηγόρημα «%s» άγνωστο το κατηγόρημα «%s» είναι άγνωστο unmatched %s quote; εκ προεπιλογής τα εισαγωγικά έχουν ειδική σημασία για το xargs εκτός κι αν χρησιμοπείτε την επιλογή -0 προειδοποίηση: τίποτα δεν ταιριάζει με -%s %s γιατί τελειώνει με /. warning: escape `\' followed by nothing at all προειδοποίηση: η οδηγία μορφοποίησης «%%%c» θα πρέπει να ακολουθείται από ένα άλλο χαρακτήρα προσοχή: η επιλογή -E δεν έχει αποτέλεσμα αν χρησιμοποιείται -0 ή -d.
 προειδοποίηση: η επιλογή -d έχει καταργηθεί, στη θέση της δώσε -depth που συμφωνεί με το POSIX. προειδοποίηση: η βάση δεδομένων locate μπορεί να διαβαστεί από stdin μια φορά. warning: there is no entry in the predicate evaluation cost table for predicate %s; please report this as a bug προειδοποίηση: μη αναγνωριζόμενη ακολουθία διαφυγής «\%c» προειδοποίηση: άγνωστη οδηγία μορφοποίησης «%%%c» προειδοποίηση: η τιμή %ld για την επιλογή -s είναι πολύ μεγάλη, οπότε χρήση της %ld προειδοποίηση: you have specified a mode pattern %s (which is equivalent to /000). The meaning of -perm /000 has now been changed to be consistent with -perm -000; that is, while it used to match no files, it now matches all files. write error πάρα πολλές «)» PRIuMAX Your environment variables take up % bytes
 POSIX upper limit on argument length (this system): %
 POSIX smallest allowable upper limit on argument length (all systems): %
 Maximum length of command we could actually use: %
 Size of command buffer we are actually using: %
 Maximum parallelism (--max-procs must be no greater): %
 Οι μεταβλητές περιβάλλοντός σου φτάνουν τα % bytes
 Άνω όριο κατά POSIX στο μήκος ορίσματος (this system): %
 Κατά POSIX το μικρότερο επιτρεπόμενο άνω όριο  στο μήκος ορίσματος (όλα τα συστήματα): %
 Μέγιστο μήκος εντολής που θα μπορούσαμε να χρησιμοποιήσουμε: %
 Μέγεθος του command buffer που χρησιμοποιούμε: %
 Μέγιστος παραλληλισμός (--max-procs όχι μεγαλύτερο): %
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     l             $        !     :     V     m            !                              )   =      g            "     -            h  $                            
       #   "     F  '   c       
     !     -                
   #  %   .  '   T     
          
                         	                                                          %s terminated by signal %d %s: exited with status 255; aborting %s: stopped by signal %d %s: terminated by signal %d argument line too long argument list too long command too long double environment is too large for exec error waiting for %s error waiting for child process invalid -size type `%c' invalid expression invalid null argument to -size oops -- invalid default insertion of and! oops -- invalid expression type! single unknown warning: unrecognized escape `\%c' warning: unrecognized format directive `%%%c' Project-Id-Version: findutils 4.1
Report-Msgid-Bugs-To: bug-findutils@gnu.org
PO-Revision-Date: 1996-10-07 22:13+0900
Last-Translator: Bang Jun-Young <bangjy@nownuri.nowcom.co.kr>
Language-Team: Korean <ko@li.org>
Language: ko
MIME-Version: 1.0
Content-Type: text/plain; charset=EUC-KR
Content-Transfer-Encoding: 8-bit
X-Bugs: Report translation errors to the Language-Team address.
 %s ȣ %d   %s:  255  ; ߴ %s: ȣ %d   %s: ȣ %d   μ  ʹ ϴ μ  ʹ ϴ  ʹ ϴ ι ȯ (exec)ϱ⿡ ʹ Ůϴ %s ٸ   ߻ ڽ μ ٸ   ߻  -size  `%c'   -size   μ ־  -- and ġ ϰ ߽ϴ!  --   Դϴ!     : ν   ̽ `\%c' : ν     `%%%c'                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     